Plan. Retrieve. Reason. Collaborate. Execute. Verify.
AgentForge is an extensible multi-agent AI platform built around
LangGraph, hybrid RAG, knowledge graphs, MCP tools,
human-in-the-loop workflows, persistent state, and real-time streaming.
Why AgentForge • Architecture • Capabilities • Quick Start • Roadmap
Most AI applications still look like this:
┌──────────┐ ┌─────────┐ ┌──────────┐
│ USER │ ───► │ LLM │ ───► │ ANSWER │
└──────────┘ └─────────┘ └──────────┘
AgentForge is built around a different execution model:
┌──────────────┐
│ USER │
└──────┬───────┘
│
▼
┌─────────────────┐
│ INTENT ROUTER │
└───────┬─────────┘
│
▼
┌─────────────────┐
│ SUPERVISOR │
└───────┬─────────┘
│
┌────────────────┼────────────────┐
│ │ │
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ WEB/RAG │ │ GRAPH │ │ MATH │
│ AGENT │ │ AGENT │ │ AGENT │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
└────────────────┼────────────────┘
▼
┌──────────────────┐
│ TOOLS / MCP │
└────────┬─────────┘
▼
┌──────────────────┐
│ HUMAN APPROVAL │
└────────┬─────────┘
▼
┌──────────────────┐
│ EVALUATION │
└────────┬─────────┘
▼
FINAL ANSWER
The current implementation already includes a 12-agent LangGraph workflow, routing, RAG, knowledge-graph reasoning, web retrieval, HITL, persistence, and evaluation.
AgentForge is built for people who want to move from:
"LLM wrapper"
to:
"AI system."
It combines multiple AI engineering patterns in one extensible foundation:
|
Agent Orchestration Supervisor-driven LangGraph workflows with specialized reasoning stages. |
Hybrid RAG Vector retrieval + lexical retrieval + fusion + reranking. |
Knowledge Graph Relationship-aware reasoning over local knowledge. |
|
MCP External tool integration with local fallbacks. |
HITL Pause workflows and require explicit approval. |
Persistent State Checkpointed graph state + durable conversations. |
|
Streaming Real-time FastAPI streaming endpoints. |
Observability Prometheus + Grafana + health/readiness probes. |
Authentication User-scoped authenticated workflows. |
These capabilities are already represented in the repository's current implementation and documentation.
AgentForge currently orchestrates:
01 Safety
02 Intent Routing
03 Clarification
04 Query Rewriting
05 Recency Guard
06 Human Approval Gate
07 Web Retrieval
08 Knowledge Graph Reasoning
09 RAG
10 Mathematical Reasoning
11 Response Generation
12 Evaluation
A user does not need to know which AI mechanism is appropriate.
AgentForge decides:
"What kind of reasoning does this task require?"
↓
"Which information sources are relevant?"
↓
"Which tools should be used?"
↓
"Does this require approval?"
↓
"How should the answer be verified?"
AgentForge's local RAG pipeline combines multiple retrieval strategies:
QUERY
│
┌──────────┴──────────┐
▼ ▼
Semantic Retrieval Lexical Retrieval
(Vector) (BM25)
│ │
└──────────┬──────────┘
▼
Rank Fusion
│
▼
Reranking
│
▼
Grounded Context
The current Chroma-based pipeline supports vector retrieval, lexical ranking, Reciprocal Rank Fusion, and optional LLM reranking.
Not every question is semantic.
Some questions are about relationships.
AgentForge provides a dedicated graph-oriented retrieval path:
Documents
↓
Graph-RAG Store
↓
Relationship Retrieval
↓
NetworkX Reasoning
↓
RAG Grounding
↓
Answer
This is designed for relationship-style local queries and uses a separate graph-RAG ingestion path.
AgentForge supports MCP-backed tools through a dedicated bridge architecture.
Agent
│
▼
MCP Bridge
│
▼
MCP Tool Server
╱ ╲
▼ ▼
Web Search Calculator
The current implementation also provides local fallbacks when MCP is unavailable.
AI does not have to blindly continue every workflow.
For supported tasks:
Agent
│
▼
Proposed
Action
│
┌────┴────┐
▼ ▼
APPROVE REJECT
│ │
▼ ▼
CONTINUE STOP
AgentForge isn't designed around a disposable request.
Graph State
↓
Checkpoint
↓
Resume
User
↓
Thread
↓
Messages
↓
Metadata
↓
Audit
The documented persistence layer includes PostgreSQL checkpointer tables, conversation storage, users, and HITL events.
POST /invoke
POST /streamGET /healthz
GET /readyz
GET /metricsGET /store/threads
GET /store/{thread_id}
POST /feedbackThe project also exposes authenticated registration/login and HITL audit endpoints.
AgentForge ships with:
FastAPI
│
▼
/metrics
│
▼
Prometheus
│
▼
Grafana
You can monitor:
- request rate
- 5xx error rate
- P95 latency
- traffic by endpoint
- status-code distribution
┌───────────────────┐
│ USER │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ FASTAPI │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ INTENT ROUTER │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ SUPERVISOR │
└─────────┬─────────┘
│
┌────────────────┼────────────────┐
│ │ │
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ WEB │ │ RAG │ │ GRAPH │
│ AGENT │ │ AGENT │ │ AGENT │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
└────────────────┼────────────────┘
│
▼
┌───────────────────┐
│ MCP / TOOLS │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ HITL GATE │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ EVALUATION │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ FINAL RESPONSE │
└───────────────────┘
| Layer | Technology |
|---|---|
| 🐍 Backend | Python |
| ⚡ API | FastAPI |
| 🧠 Orchestration | LangGraph |
| 🖥️ UI | Streamlit |
| 🐘 Persistence | PostgreSQL |
| 🔎 RAG | ChromaDB |
| 🕸️ Graph | NetworkX |
| 🔌 Tools | MCP |
| ⚡ Cache | Redis / in-memory fallback |
| 📈 Monitoring | Prometheus + Grafana |
| 🐳 Containers | Docker |
| ☸️ Deployment | Kubernetes |
| 🔁 CI/CD | GitHub Actions |
AgentForge/
│
├── frontend/ # Next.js 16 Multi-Agent Workbench (React 19, Turbopack, Tailwind v4)
├── agent/ # AI orchestration + agents + tools
├── client/ # Python client
├── service/ # FastAPI service + persistence
├── schema/ # Request / response schemas
├── scripts/ # RAG ingestion & tests
├── docs/ # Architecture & integration documentation
├── docker/ # Container definitions
├── k8s/ # Kubernetes manifests
├── monitoring/ # Prometheus configuration
├── media/ # Architecture assets
│
├── compose.yaml
├── run_service.py
├── run_client.py
├── streamlit_app.py
├── requirements.txt
└── README.md
The current repository separates orchestration, tools, local RAG, graph RAG, persistence, service APIs, monitoring, deployment, and the modern Next.js 16 workbench.
The repository currently includes:
- Python tests
- Docker build verification
- push/PR triggers
- version-tag releases
- Docker image publishing
- manual dispatch
These workflows are already documented in the repository.
AgentForge includes an enterprise-grade web application built with Next.js 16 (App Router), React 19, TailwindCSS v4, and Framer Motion physics.
-
Mission Control (
/dashboard): Asymmetric bento grid with real-time/healthzliveness,/readyzcomponent readiness, SQLite conversational thread counts, and OpenMetrics request rates. -
Agent Playground (
/playground): Real-time Server-Sent Events (SSE) token streaming, dynamic model selection (llama-3.3-70b-versatile), inline Human-in-the-Loop authorization gates, and LangSmith feedback scoring. -
Session History (
/conversations): Persistent multi-turn conversation storage with turn-by-turn inspection, checkpoint restore, and one-click JSON transcript download. -
Workflow Topology (
/workflows): Interactive visualization of the 12-agent LangGraph supervisor hierarchy, execution stages, and deterministic routing paths. -
HITL Approvals (
/approvals): Dedicated supervisory queue allowing human operators to preview search results, approve/reject web queries, and maintain an immutable decision audit log. -
Knowledge RAG (
/knowledge): Explains and simulates the 6-stage Hybrid RAG pipeline (Reciprocal Rank Fusion with$K=60$ ) alongside an interactive SVG Knowledge Graph entity explorer. -
MCP Tool Registry (
/tools): FastMCP tool execution sandbox with JSON schema inspection forweb_searchandcalculate. -
Platform Telemetry (
/observability): Real-time Prometheus OpenMetrics parser with HTTP status code distributions (2xx, 3xx, 4xx, 5xx), average latency, and memory monitoring. -
Settings & Security (
/settings): Session identity management, PBKDF2 parameters, inference preferences, and theme toggle.
cd frontend
npm install
npm run devOpen http://localhost:3000 in your browser.
Run automated integration tests:
npm testCreate production build:
npm run buildgit clone https://github.com/Roshanrameshhub/AgentForge.git
cd AgentForgepip install -r requirements.txtpython run_service.pystreamlit run streamlit_app.pydocker compose up -d --buildThe documented local stack includes FastAPI, Streamlit, Prometheus, and Grafana.
Place PDFs inside:
rag_docs/
Run:
python scripts/ingestion/ingest_local_rag_pdfs.py \
--pdf-dir rag_docs \
--resetThen ask:
local: summarize the uploaded documents
For graph-oriented documents:
graph_rag_docs/
python scripts/ingestion/ingest_graph_rag_pdfs.py \
--pdf-dir graph_rag_docs \
--resetAgentForge is evolving toward a broader autonomous AI workbench.
- LangGraph supervisor
- Multi-agent workflow
- Hybrid RAG
- Knowledge graph reasoning
- MCP tools
- Human-in-the-loop
- Persistent graph state
- Conversation persistence
- Streaming
- Monitoring
- Authentication
- Dynamic task planning
- Parallel agent execution
- Long-term memory
- Context compression
- Agent verification
- Self-correction
- Better evaluation
- Advanced retrieval
- Multimodal AI
- Realtime voice
- Computer-use workflows
- Expanded MCP ecosystem
- Agent/plugin marketplace
- Autonomous multi-step execution
The existing codebase already provides the supervisor, retrieval, HITL, persistence, MCP, and monitoring foundations on which these capabilities can evolve.
The current implementation is strong as an orchestration foundation but is still evolving.
Known limitations include:
- heuristic evaluation rather than complete factual verification
- clarification requiring a subsequent user turn
- possible routing errors for ambiguous inputs
- retrieval quality depending on ingestion, embeddings, chunking, and reranking quality
AgentForge can serve as a foundation for building:
Research Agents
Developer Copilots
Knowledge Assistants
Document Intelligence
Enterprise AI Workflows
Autonomous Task Systems
Multi-Agent Applications
The underlying goal is simple:
Don't build another chatbot. Build a system that can reason through work.
Contributions are welcome across:
- new agents
- retrieval strategies
- MCP integrations
- security
- evaluation
- observability
- agent state
- multimodal workflows
- performance optimization
AgentForge is distributed under the MIT License.
See LICENSE for the full terms.
This project is derived from an MIT-licensed open-source foundation and has been renamed and substantially extended as AgentForge. Original license and copyright notices are retained.
The orchestration layer for the next generation of AI applications.