LangGraph create_react_agent Binding Errors

from typing import Annotated
from langchain_core.tools import tool
from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import MemorySaver


# ✅ Model that supports native tool calling
model = ChatAnthropic(
    model="claude-opus-4-7",       # or "claude-sonnet-4-5", "claude-haiku-4-5"
    temperature=0.2,
)


# ✅ Tools decorated with @tool — schema auto-derived from type hints + docstring
@tool
def search(query: str, top_k: int = 5) -> list[str]:
    """Search the web for the given query and return top_k result URLs."""
    # ... call your search API ...
    return [f"https://example.com/{i}" for i in range(top_k)]


@tool
def calculator(expression: str) -> float:
    """Evaluate a mathematical expression and return the numeric result."""
    return float(eval(expression, {"__builtins__": {}}))


# ✅ Pydantic schema for typed args (optional, cleaner for complex tools)
from pydantic import BaseModel, Field

class SearchArgs(BaseModel):
    query: str = Field(min_length=1, description="Search query text")
    top_k: int = Field(default=5, ge=1, le=20, description="Number of results")

@tool(args_schema=SearchArgs)
def typed_search(query: str, top_k: int = 5) -> list[str]:
    """Search with validated arguments."""
    return search.invoke({"query": query, "top_k": top_k})


# ✅ Build the agent
agent = create_react_agent(
    model=model,
    tools=[search, calculator],
    prompt="You are a helpful assistant. Use tools when needed.",
    checkpointer=MemorySaver(),
)


# ✅ Invoke
config = {"configurable": {"thread_id": "session-1"}}
result = agent.invoke(
    {"messages": [("user", "What is 27 * 43?")]},
    config,
)
for m in result["messages"]:
    m.pretty_print()
# HumanMessage: What is 27 * 43?
# AIMessage: [tool_call: calculator(expression="27 * 43")]
# ToolMessage: 1161.0
# AIMessage: 27 multiplied by 43 is 1,161.


# ❌ COMMON BUGS
# 1. Old model: model = ChatAnthropic(model="claude-instant-1.2")  # no tool support
# 2. Raw function: agent = create_react_agent(model, tools=[search])
#    where def search(q): ...  # not @tool-decorated
# 3. Missing docstring on @tool — model gets an empty description

from typing import Annotated
from langgraph.prebuilt import create_react_agent
from langgraph.prebuilt.chat_agent_executor import AgentState


# ✅ Subclass AgentState — messages field is inherited
class MyAgentState(AgentState):
    user_id: str
    intent: str | None
    tool_call_count: int


# ✅ Custom state modifier (function that runs before every model call)
from langchain_core.messages import SystemMessage

def state_modifier(state: MyAgentState) -> list:
    """Inject dynamic system context — runs on every turn."""
    system = SystemMessage(
        content=f"You are helping user {state['user_id']}. "
                f"Detected intent: {state.get('intent', 'unknown')}. "
                f"Tools called so far: {state.get('tool_call_count', 0)}."
    )
    return [system] + state["messages"]


agent = create_react_agent(
    model=model,
    tools=[search, calculator],
    state_schema=MyAgentState,           # subclass, not TypedDict from scratch
    prompt=state_modifier,               # dynamic prompt as a function
    checkpointer=MemorySaver(),
)


# ✅ Invoke — provide values for the extra fields
config = {"configurable": {"thread_id": "user-42"}}
result = agent.invoke({
    "messages": [("user", "help me plan a trip")],
    "user_id": "user-42",
    "intent": "travel_planning",
    "tool_call_count": 0,
}, config)


# ❌ ANTI-PATTERN — starting from scratch and missing messages
# class BrokenState(TypedDict):
#     user_id: str
#     intent: str
# # Missing messages field — create_react_agent will fail at first invoke
# agent = create_react_agent(model, tools, state_schema=BrokenState)


# ✅ If you MUST write from scratch, include the messages channel
from typing import TypedDict
from langchain_core.messages import AnyMessage
from langgraph.graph.message import add_messages

class HandmadeState(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]   # required
    user_id: str
    intent: str

from pydantic import BaseModel, Field
from langchain_core.messages import SystemMessage
from langgraph.prebuilt import create_react_agent


# ✅ Prompt that reinforces tool use rather than replacing default guidance
SYSTEM = """You are a research assistant.

You have access to a `search` tool for facts and a `calculator` tool for math.
Use tools whenever the answer requires up-to-date info or arithmetic.
Cite sources for factual claims.
Respond in plain English unless the user asks for structured output.
"""

agent = create_react_agent(
    model=model,
    tools=[search, calculator],
    prompt=SystemMessage(content=SYSTEM),    # SystemMessage keeps tool guidance intact
    checkpointer=MemorySaver(),
)


# ✅ response_format — forces the final message to match a schema
class TripPlan(BaseModel):
    destination: str
    duration_days: int = Field(ge=1, le=30)
    estimated_cost_usd: float = Field(ge=0)
    activities: list[str] = Field(min_length=1, max_length=10)
    citations: list[str]

typed_agent = create_react_agent(
    model=model,
    tools=[search],
    prompt=SystemMessage(content="You are a trip planner. Cite every fact."),
    response_format=TripPlan,                # Pydantic model as schema
    checkpointer=MemorySaver(),
)

result = typed_agent.invoke(
    {"messages": [("user", "Plan a 5-day trip to Kyoto under $2000")]},
    {"configurable": {"thread_id": "trip-1"}},
)

# Final validated output is under result["structured_response"]
plan: TripPlan = result["structured_response"]
print(plan.destination, plan.estimated_cost_usd)
for act in plan.activities:
    print("-", act)


# ❌ BUG — bare string prompt REPLACES tool usage guidance
# agent = create_react_agent(
#     model=model,
#     tools=[search, calculator],
#     prompt="Be concise.",              # <-- no mention of tools; model may skip them
# )


# ✅ Callable prompt for full control — must return list[BaseMessage]
def dynamic_prompt(state):
    from datetime import datetime
    system = SystemMessage(content=(
        f"Today is {datetime.now():%Y-%m-%d}. "
        "You have tools: search, calculator. Use them when appropriate."
    ))
    return [system] + state["messages"]

agent2 = create_react_agent(model, tools=[search, calculator], prompt=dynamic_prompt)