Arquitecturas de Agentes

// ReAct agent implementation with LangChain
import { ChatAnthropic } from "@langchain/anthropic";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
import { Calculator } from "@langchain/community/tools/calculator";

const model = new ChatAnthropic({
  model: "claude-sonnet-4-20250514",
  temperature: 0,
});

const tools = [
  new TavilySearchResults({ maxResults: 3 }),
  new Calculator(),
];

// Create a ReAct agent with LangGraph
const agent = createReactAgent({
  llm: model,
  tools: tools,
});

// Run the agent
const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "What is the population of Tokyo and what is it divided by 3?",
    },
  ],
});

console.log(result.messages[result.messages.length - 1].content);

# ReAct agent implementation with LangChain Python
from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import create_react_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_community.tools import DuckDuckGoSearchRun

model = ChatAnthropic(model="claude-sonnet-4-20250514", temperature=0)

tools = [
    TavilySearchResults(max_results=3),
    DuckDuckGoSearchRun(),
]

# Create a ReAct agent
agent = create_react_agent(model, tools)

# Run the agent
result = agent.invoke({
    "messages": [
        {"role": "user", "content": "Research the latest AI agent frameworks in 2026"}
    ]
})

print(result["messages"][-1].content)

// Plan-and-Execute pattern
import { ChatAnthropic } from "@langchain/anthropic";

const planner = new ChatAnthropic({ model: "claude-sonnet-4-20250514" });
const executor = new ChatAnthropic({ model: "claude-sonnet-4-20250514" });

interface Plan {
  steps: string[];
  currentStep: number;
}

async function planAndExecute(task: string): Promise<string> {
  // Phase 1: Planning
  const planResponse = await planner.invoke([
    {
      role: "system",
      content: `Create a step-by-step plan to accomplish the task.
Return a JSON array of steps. Each step should be a clear, actionable instruction.`,
    },
    { role: "user", content: task },
  ]);

  const plan: Plan = {
    steps: JSON.parse(planResponse.content as string),
    currentStep: 0,
  };

  // Phase 2: Execution
  const results: string[] = [];

  for (const step of plan.steps) {
    const execResponse = await executor.invoke([
      {
        role: "system",
        content: `Execute this step. Previous results: ${results.join("\n")}`,
      },
      { role: "user", content: step },
    ]);

    results.push(execResponse.content as string);
    plan.currentStep++;
  }

  // Phase 3: Synthesize
  return results.join("\n\n");
}

# Plan-and-Execute pattern in Python
from langchain_anthropic import ChatAnthropic
import json

planner = ChatAnthropic(model="claude-sonnet-4-20250514")
executor = ChatAnthropic(model="claude-sonnet-4-20250514")

async def plan_and_execute(task: str) -> str:
    # Phase 1: Create a plan
    plan_response = planner.invoke([
        {"role": "system", "content": """Create a step-by-step plan.
Return a JSON array of actionable steps."""},
        {"role": "user", "content": task}
    ])

    steps = json.loads(plan_response.content)

    # Phase 2: Execute each step
    results = []
    for step in steps:
        exec_response = executor.invoke([
            {"role": "system", "content": f"Execute this step. Context: {results}"},
            {"role": "user", "content": step}
        ])
        results.append(exec_response.content)

    # Phase 3: Synthesize results
    return "\n\n".join(results)

# Multi-agent system with LangGraph
from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-20250514")

# Define specialized agents as nodes
def researcher(state: MessagesState):
    """Agent specialized in research and information gathering."""
    response = model.invoke([
        {"role": "system", "content": "You are a research specialist. Find accurate information."},
        *state["messages"]
    ])
    return {"messages": [response]}

def analyst(state: MessagesState):
    """Agent specialized in data analysis and insights."""
    response = model.invoke([
        {"role": "system", "content": "You are a data analyst. Analyze the information provided."},
        *state["messages"]
    ])
    return {"messages": [response]}

def writer(state: MessagesState):
    """Agent specialized in writing clear reports."""
    response = model.invoke([
        {"role": "system", "content": "You are a writer. Create a clear, well-structured report."},
        *state["messages"]
    ])
    return {"messages": [response]}

# Build the multi-agent graph
graph = StateGraph(MessagesState)
graph.add_node("researcher", researcher)
graph.add_node("analyst", analyst)
graph.add_node("writer", writer)

graph.add_edge(START, "researcher")
graph.add_edge("researcher", "analyst")
graph.add_edge("analyst", "writer")
graph.add_edge("writer", END)

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "Analyze AI agent trends"}]})

// Tool-use pattern with Anthropic's native function calling
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: "get_weather",
    description: "Get current weather for a location",
    input_schema: {
      type: "object" as const,
      properties: {
        location: { type: "string", description: "City name" },
      },
      required: ["location"],
    },
  },
  {
    name: "search_database",
    description: "Search the product database",
    input_schema: {
      type: "object" as const,
      properties: {
        query: { type: "string", description: "Search query" },
        limit: { type: "number", description: "Max results" },
      },
      required: ["query"],
    },
  },
];

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  tools: tools,
  messages: [
    { role: "user", content: "What's the weather in San Francisco?" },
  ],
});

// Process tool use blocks
for (const block of response.content) {
  if (block.type === "tool_use") {
    console.log(`Tool: ${block.name}, Input: ${JSON.stringify(block.input)}`);
  }
}