Architecture - langchain-multi-agent-framework

Executive Summary

A multi-agent orchestration framework built on LangChain, LangGraph, and CrewAI patterns. It provides a supervisor-driven StateGraph that routes tasks to specialized agents -- Planner, Researcher, Coder, and Reviewer -- which collaborate through shared memory. The framework supports multiple LLM providers (OpenAI, Anthropic, Azure OpenAI), multiple vector store backends (ChromaDB, Pinecone, Weaviate), and includes tools for web search (Tavily, SerpAPI, DuckDuckGo), sandboxed code execution, and RAG retrieval. Designed for research workflows, development teams, and knowledge-base-backed customer support.

Overview

Python

Language

AI/ML

Architecture Diagram

User Request

Supervisor Node
Routes tasks to agents

Planner Agent
Task decomposition

Researcher Agent
Web search + RAG

Coder Agent
Code generation

Reviewer Agent
Quality assurance

LangGraph StateGraph Orchestrator (cyclic routing back to Supervisor)

Web Search
Tavily / SerpAPI / DDG

Code Executor
Sandboxed Python

Vector Store
ChromaDB / Pinecone

Shared Memory
Thread-Safe State

Agent Tools + Shared State

Final Output

Component Breakdown

Component	File	Purpose	Key Dependencies
Orchestrator	`src/orchestrator.py`	LangGraph StateGraph with supervisor routing	langgraph, langchain
Configuration	`src/config.py`	Dataclass-based config for LLM, vector store, agents	pydantic
Base Agent	`src/agents/base_agent.py`	Abstract base with LLM factory (OpenAI/Anthropic/Azure)	langchain-openai, langchain-anthropic
Planner	`src/agents/planner.py`	Task decomposition into sub-tasks	Base agent
Researcher	`src/agents/researcher.py`	Web search and RAG-based research	Web search tool, vector store
Coder	`src/agents/coder.py`	Code generation with sandboxed execution	Code executor tool
Reviewer	`src/agents/reviewer.py`	Code review and quality assurance	Base agent
Web Search	`src/tools/web_search.py`	Multi-provider web search (Tavily, SerpAPI, DDG)	tavily-python, duckduckgo-search
Code Executor	`src/tools/code_executor.py`	Sandboxed Python code execution	subprocess (stdlib)
Vector Store	`src/tools/vector_store.py`	RAG retrieval from ChromaDB/Pinecone/Weaviate	langchain-chroma, chromadb
Shared Memory	`src/memory/conversation.py`	Thread-safe shared memory for inter-agent communication	threading (stdlib)

Data Flow / Request Flow

User Request -- User submits a task description to orchestrator.run().
Supervisor Routing -- The supervisor node analyzes the request and routes to the appropriate agent (plan, research, code, review, or done).
Agent Execution -- Each agent processes its assigned sub-task using its tools and LLM. Results are written to shared memory.
Cyclic Routing -- After each agent completes, control returns to the supervisor, which decides the next step or terminates.
Tool Usage -- Researcher uses web search and vector store retrieval. Coder uses sandboxed code execution. All agents read/write shared memory.
Recursion Limit -- The graph enforces a configurable recursion limit (default 50) to prevent infinite loops.
Final Output -- When the supervisor routes to "done", the final state containing all agent results is returned.

Security Controls

Control	Implementation
API Key Management	Environment variables via python-dotenv; supports OpenAI, Anthropic, and Azure keys
Sandboxed Execution	Code executor runs Python in isolated subprocess with resource limits
Recursion Limit	Configurable graph recursion limit prevents runaway agent loops
Agent Timeout	Per-agent execution timeout (default 300s)
Thread Safety	Shared memory uses thread-safe locking for concurrent agent access
Input Validation	Pydantic v2 models for all configuration structures

Industry Adaptation

Healthcare

Clinical research teams with medical literature RAG. HIPAA-compliant data retrieval with filtered vector stores. Medical coding assistance agents.

Finance

Financial analysis research with regulatory document RAG. Automated due diligence report generation. Compliance review agents for SEC filings.

Government

Policy analysis and legislative research. Classified-environment compatible with air-gapped LLM providers. Multi-agency knowledge base aggregation.

Retail

Product catalog research and competitive analysis. Customer support with product knowledge RAG. Automated content generation for marketing.

SaaS

Developer documentation assistance. Automated code review and quality gates. Technical support with codebase-aware RAG retrieval.

Production Readiness Checklist

Configure LLM provider API key (OpenAI, Anthropic, or Azure OpenAI)
Select and configure vector store backend (ChromaDB local, Pinecone, or Weaviate)
Configure search API key (Tavily preferred, SerpAPI fallback)
Set recursion_limit appropriate for workload complexity
Populate vector store with domain-specific documents for RAG
Customize agent system prompts for domain-specific behavior
Test with sample tasks and validate output quality
Configure execution timeouts for production workloads
Set up logging and monitoring for agent execution traces
Review code executor sandbox security for production deployment

Configuration / Environment Variables

Variable	Required	Default	Description
`OPENAI_API_KEY`	Yes*	--	OpenAI API key (*or use another provider)
`ANTHROPIC_API_KEY`	No	--	Anthropic API key (alternative provider)
`AZURE_OPENAI_API_KEY`	No	--	Azure OpenAI API key (alternative provider)
`LLM_PROVIDER`	No	openai	LLM provider: openai, anthropic, azure_openai
`LLM_MODEL`	No	gpt-4o	Model identifier
`LLM_TEMPERATURE`	No	0.0	Sampling temperature
`LLM_MAX_TOKENS`	No	4096	Maximum output tokens
`TAVILY_API_KEY`	No	--	Tavily search API key (preferred search)
`SERPAPI_API_KEY`	No	--	SerpAPI key (fallback search)

Deployment

Local Development

git clone https://github.com/your-org/langchain-multi-agent-framework.git
cd langchain-multi-agent-framework
python -m venv .venv
source .venv/bin/activate
pip install -e ".[search,dev]"
cp .env.example .env
python -m examples.research_team

Production

# Install with preferred vector store:
pip install -e ".[search]"       # ChromaDB (default)
pip install -e ".[search,pinecone]"  # Pinecone
pip install -e ".[search,weaviate]"  # Weaviate

# Run as async service:
# await orchestrator.arun("task")

Links

Repository	github.com/your-org/langchain-multi-agent-framework
README	README.md
Changelog	CHANGELOG.md
License	MIT License