You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# Tutorial: Building an Agentic AI System with Deductive & Inductive Reasoning
## 1. Introduction
Modern AI systems increasingly require the ability to make decisions in complex and dynamic environments. One promising approach is to create an **agentic AI system** that combines:
-**Deductive Reasoning:** Rule-based logic that guarantees conclusions when premises hold true.
-**Inductive Reasoning:** Data-driven inference that generalizes from specific cases to handle uncertainty.
By integrating these two methods, often referred to as **neuro-symbolic AI**, an agent can provide transparent, explainable decisions while also adapting to new data. This tutorial explains the concepts behind this approach and shows you how to build an edge-deployable ReAct agent using Deno.
---
## 2. Benefits of an Agentic AI System
Implementing a hybrid reasoning system brings several advantages:
-**Robust Decision-Making:**
Deductive logic ensures consistency when rules are met, while inductive reasoning fills gaps by generalizing from data. This results in decisions that are both reliable and adaptable.
geeksforgeeks.org
-**Transparency and Explainability:**
Rule-based components allow you to trace the logic behind decisions. When combined with inductive estimates, the agent can provide a detailed explanation of its thought process.
zilliz.com
-**Modularity and Customization:**
The design is modular. You can add or modify rules for various domains (e.g., financial, medical, legal) without overhauling the entire system. This makes it ideal for specialized applications.
aisera.com
-**Edge-Optimized Deployment:**
Implementing the agent as a single-file Deno script keeps the code lightweight and fast, ideal for serverless environments such as Supabase Edge Functions or Fly.io.
---
## 3. Usage Overview
The agent is built around the **ReAct loop**, which follows these steps:
1.**Input Parsing:**
The agent receives a JSON request containing a `query` and optionally a `domain` field. The domain field (e.g., "financial", "medical", "legal") directs the reasoning engine to use domain-specific rules.
2.**Agentic Reasoning:**
-**Deductive Module:** Checks for explicit rules. For example, in finance, it might check if the expected return is high and risk is low to advise investment.
-**Inductive Module:** If no deductive rule applies, the agent uses past data or heuristic matching to suggest a probable outcome (e.g., inferring a diagnosis from similar past cases).
3.**LLM Integration & Tool Usage:**
The agent communicates with an LLM (via OpenRouter API) following the ReAct pattern. It can take actions by invoking tools (e.g., a calculator) and then incorporate the resulting observation into its next reasoning step.
4.**Final Answer Generation:**
Once the agent reaches a confident conclusion, it outputs the final answer in a JSON response.
Below is the full TypeScript code. Save this as a single file (e.g., `index.ts`) for deployment with Deno.
```typescript
/**
* Agentic ReAct Agent Template (Deno)
*
* This agent follows the ReAct (Reasoning + Acting) logic pattern, integrates with the OpenRouter API for LLM interactions,
* and supports tool usage within a structured agent framework. It now also includes an agentic reasoning engine
* that combines deductive and inductive reasoning for multi-domain decision making.
*
* ## Setup
* - Ensure you have a Deno runtime available (e.g., in your serverless environment).
* - Set the environment variable `OPENROUTER_API_KEY` with your OpenRouter API key.
* - (Optional) Set `OPENROUTER_MODEL` to specify the model (default is "openai/o3-mini-high").
* - This script requires network access to call the OpenRouter API. When running with Deno, use `--allow-net` (and `--allow-env` to read env variables).
*
* ## Deployment (Fly.io)
* 1. Create a Dockerfile using a Deno base image (e.g. `denoland/deno:alpine`).
* - In the Dockerfile, copy this script into the image and use `CMD ["run", "--allow-net", "--allow-env", "agent.ts"]`.
* 2. Set the `OPENROUTER_API_KEY` as a secret on Fly.io (e.g., `fly secrets set OPENROUTER_API_KEY=your_key`).
* 3. Deploy with `fly deploy`. The app will start an HTTP server on port 8000 by default.
*
* ## Deployment (Supabase Edge Functions)
* 1. Install the Supabase CLI and login to your project.
* 2. Create a new Edge Function: `supabase functions new myagent`.
* 3. Replace the content of the generated `index.ts` with this entire script.
* 4. Ensure to add your OpenRouter API key: run `supabase secrets set OPENROUTER_API_KEY=your_key` for the function's environment.
* 5. Deploy the function: `supabase functions deploy myagent --no-verify-jwt`.
* 6. The function will be accessible at the URL provided by Supabase.
*
* ## Usage
* Send an HTTP POST request to the deployed endpoint with a JSON body: { "query": "your question", ... }.
* The response will be a JSON object: { "answer": "the answer from the agent" }.
*
* ## Customization
* - **Deductive Reasoning:** Edit or add rules in the `applyDeductive` method of the Agent class.
* - **Inductive Reasoning:** Extend the case databases (e.g., `medicalCases`, `legalCases`) or modify the matching logic in `applyInductive`.
* - **Domain Support:** The agent currently supports "financial", "medical", and "legal". Add additional domains by updating both reasoning methods.
* - **Prompt Engineering:** Modify `systemPrompt` to instruct the LLM regarding the use of tools and the desired ReAct format.
- geeksforgeeks.org – Overview of deductive reasoning and its application in AI systems.
- zilliz.com – Discussion on neuro-symbolic integration and transparency in AI reasoning.
- aisera.com – Insights into inductive reasoning and pattern recognition within AI agents.
- Deno Standard Library Documentation, available at [deno.land/std](https://deno.land/std)
- Supabase Edge Functions Documentation, available at [supabase.com/docs](https://supabase.com/docs)
---
This tutorial provided a full walkthrough—from theoretical foundations to deployment—of building an agentic AI system using a single-file TypeScript ReAct agent. You can now customize and extend this implementation for various domains, ensuring robust and transparent decision-making in your applications.
ruvnet revised this gist