AI Agent Orchestration with LangChain

LangChain approach (Python)

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_community.tools import DuckDuckGoSearchRun
from langgraph.graph import StateGraph, START, END
from typing import TypedDict

# Define shared state
class ResearchState(TypedDict):
    query: str
    search_results: str
    analysis: str
    report: str

# Step 1: Search with GPT-4o mini (cheap, fast)
search_tool = DuckDuckGoSearchRun()
search_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

def search_node(state: ResearchState) -> ResearchState:
    results = search_tool.run(state["query"])
    summary_prompt = ChatPromptTemplate.from_messages([
        ("human", "Summarize these search results: {results}")
    ])
    chain = summary_prompt | search_llm | StrOutputParser()
    state["search_results"] = chain.invoke({"results": results})
    return state

# Step 2: Analyze with Claude (strong reasoning)
analysis_llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")

def analyze_node(state: ResearchState) -> ResearchState:
    prompt = ChatPromptTemplate.from_messages([
        ("human", "Analyze these findings: {results}\nQuery: {query}")
    ])
    chain = prompt | analysis_llm | StrOutputParser()
    state["analysis"] = chain.invoke({
        "results": state["search_results"],
        "query": state["query"]
    })
    return state

# Step 3: Write report with GPT-4o (best writing)
report_llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

def report_node(state: ResearchState) -> ResearchState:
    prompt = ChatPromptTemplate.from_messages([
        ("human", "Write a professional report based on: {analysis}")
    ])
    chain = prompt | report_llm | StrOutputParser()
    state["report"] = chain.invoke({"analysis": state["analysis"]})
    return state

# Build the graph
graph = StateGraph(ResearchState)
graph.add_node("search", search_node)
graph.add_node("analyze", analyze_node)
graph.add_node("report", report_node)
graph.add_edge(START, "search")
graph.add_edge("search", "analyze")
graph.add_edge("analyze", "report")
graph.add_edge("report", END)

app = graph.compile()
result = app.invoke({"query": "AI agent orchestration trends 2025"})
print(result["report"])