# NOT an agent — you decide what to call:
weather = get_weather("Mumbai")       # you chose to call this
summary = summarise(weather)          # you chose to call this next

# IS an agent — the LLM decides what to call:
# User: "Should I carry an umbrella in Mumbai today?"
#
# LLM thinks: I need weather data → calls get_weather("Mumbai")
# LLM observes: {"temp": 28, "condition": "partly cloudy", "rain_chance": 20%}
# LLM thinks: 20% chance of rain — not high. I have enough to answer.
# LLM responds: "Probably not necessary, but a light one wouldn't hurt."
#
# The LLM made ALL the decisions. You only provided tools and a question.

import anthropic, json
from typing import Any

client = anthropic.Anthropic()

# ── Tool definitions ──────────────────────────────────
def search_web(query: str) -> str:
    return f"Search results for '{query}': [simulated results about {query}]"

def calculate(expression: str) -> str:
    try:
        result = eval(expression, {"__builtins__": {}})
        return f"{expression} = {result}"
    except Exception as e:
        return f"Error: {e}"

def get_current_time() -> str:
    from datetime import datetime
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

TOOLS = [
    {"name": "search_web",
     "description": "Search the web for current information. Use when you need facts not in your training data.",
     "input_schema": {"type": "object", "properties": {
         "query": {"type": "string", "description": "The search query"}},
         "required": ["query"]}},
    {"name": "calculate",
     "description": "Evaluate a mathematical expression. Use for any arithmetic.",
     "input_schema": {"type": "object", "properties": {
         "expression": {"type": "string"}}, "required": ["expression"]}},
    {"name": "get_current_time",
     "description": "Get the current date and time.",
     "input_schema": {"type": "object", "properties": {}}},
]

TOOL_REGISTRY = {"search_web": search_web,
                 "calculate": calculate,
                 "get_current_time": get_current_time}

# ── ReAct agent loop ──────────────────────────────────
def run_agent(user_message: str, system: str = "",
              max_turns: int = 10) -> str:
    messages = [{"role": "user", "content": user_message}]

    for turn in range(max_turns):
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=4096,
            system=system,
            tools=TOOLS,
            messages=messages
        )

        # Agent finished — return final text
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return ""

        # Agent wants to use tools
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})

            tool_results = []
            for block in response.content:
                if block.type != "tool_use":
                    continue
                func = TOOL_REGISTRY.get(block.name)
                if func is None:
                    result = {"error": f"Unknown tool: {block.name}"}
                else:
                    try:
                        result = func(**block.input)
                    except Exception as e:
                        result = {"error": str(e)}

                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": str(result)
                })

            messages.append({"role": "user", "content": tool_results})

    return f"Agent reached max_turns ({max_turns}) without completing."

# Run the agent
answer = run_agent(
    "What is the square root of 1764, and what day of the week is it today?"
)
print(answer)

from dataclasses import dataclass, field
from typing import Any, Optional
from datetime import datetime

@dataclass
class AgentState:
    # Core
    messages:      list[dict]       = field(default_factory=list)
    turn_count:    int              = 0
    started_at:    str              = field(default_factory=lambda: datetime.utcnow().isoformat())

    # Tool tracking
    tools_called:  list[str]        = field(default_factory=list)
    tool_results:  dict[str, Any]   = field(default_factory=dict)

    # Working memory — agent can store intermediate findings
    scratch_pad:   dict[str, Any]   = field(default_factory=dict)

    # Task tracking
    goal:          str              = ""
    subtasks:      list[str]        = field(default_factory=list)
    completed:     list[str]        = field(default_factory=list)
    status:        str              = "running"   # running | waiting | done | failed

    # Human interaction
    awaiting_approval: bool         = False
    pending_action:    Optional[dict] = None

def agent_with_state(user_message: str, state: AgentState = None) -> AgentState:
    if state is None:
        state = AgentState(goal=user_message)

    state.messages.append({"role": "user", "content": user_message})

    while state.status == "running" and state.turn_count < 10:
        state.turn_count += 1
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=4096,
            tools=TOOLS,
            messages=state.messages
        )

        if response.stop_reason == "end_turn":
            state.status = "done"
            for block in response.content:
                if hasattr(block, "text"):
                    state.messages.append({"role": "assistant", "content": block.text})
            break

        state.messages.append({"role": "assistant", "content": response.content})

        tool_results = []
        for block in response.content:
            if block.type != "tool_use":
                continue
            state.tools_called.append(block.name)
            result = TOOL_REGISTRY.get(block.name, lambda **k: "unknown tool")(**block.input)
            state.tool_results[block.id] = result
            tool_results.append({"type": "tool_result",
                                  "tool_use_id": block.id, "content": str(result)})

        state.messages.append({"role": "user", "content": tool_results})

    return state

pip install langgraph langchain-anthropic

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
from typing import TypedDict, Annotated
import operator

# ── 1. Define state schema ────────────────────────────
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]   # reducer: add new messages

# ── 2. Define nodes ───────────────────────────────────
llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")
llm_with_tools = llm.bind_tools(langchain_tools)   # tools bound to LLM

def call_llm(state: AgentState) -> dict:
    """LLM node — decides what to do next."""
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def execute_tools(state: AgentState) -> dict:
    """Tool node — executes all pending tool calls."""
    last_message = state["messages"][-1]
    tool_results = []
    for tool_call in last_message.tool_calls:
        func  = TOOL_REGISTRY[tool_call["name"]]
        result = func(**tool_call["args"])
        tool_results.append(ToolMessage(
            content=str(result),
            tool_call_id=tool_call["id"]
        ))
    return {"messages": tool_results}

# ── 3. Conditional edge — route based on state ────────
def should_continue(state: AgentState) -> str:
    """Return 'tools' if LLM wants to call tools, 'end' if done."""
    last = state["messages"][-1]
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "tools"
    return "end"

# ── 4. Build the graph ────────────────────────────────
graph = StateGraph(AgentState)

graph.add_node("llm",   call_llm)
graph.add_node("tools", execute_tools)

graph.set_entry_point("llm")
graph.add_conditional_edges("llm", should_continue, {
    "tools": "tools",
    "end":   END
})
graph.add_edge("tools", "llm")   # after tools, always go back to LLM

# ── 5. Compile with checkpointer (persistence) ────────
memory  = MemorySaver()
agent   = graph.compile(checkpointer=memory)

# ── 6. Run the agent ──────────────────────────────────
config  = {"configurable": {"thread_id": "session-123"}}
result  = agent.invoke(
    {"messages": [HumanMessage(content="What is 15% of 8500 and what is today's date?")]},
    config=config
)
print(result["messages"][-1].content)

from langgraph.graph import StateGraph, END, interrupt

# ── Interrupt before executing a tool ─────────────────
SENSITIVE_TOOLS = {"send_email", "delete_record", "make_payment"}

def execute_tools_with_approval(state: AgentState) -> dict:
    last_message = state["messages"][-1]
    tool_results = []

    for tool_call in last_message.tool_calls:
        tool_name = tool_call["name"]

        if tool_name in SENSITIVE_TOOLS:
            # Pause and ask human for approval
            approval = interrupt({
                "question": f"Agent wants to call {tool_name} with args: {tool_call['args']}. Approve?",
                "tool_name": tool_name,
                "tool_args": tool_call["args"]
            })
            if not approval.get("approved"):
                tool_results.append(ToolMessage(
                    content="User declined this action.",
                    tool_call_id=tool_call["id"]
                ))
                continue

        # Approved or non-sensitive — execute
        result = TOOL_REGISTRY[tool_name](**tool_call["args"])
        tool_results.append(ToolMessage(content=str(result),
                                        tool_call_id=tool_call["id"]))

    return {"messages": tool_results}

# ── Resuming after human approval ─────────────────────
# When the graph is interrupted, it returns a snapshot
# The human inspects and provides a response
# Then you resume with Command(resume=response)

from langgraph.types import Command

# Graph pauses here, returns to caller
result = agent.invoke(task, config)

# Human reviews the interrupt value
pending = result["__interrupt__"]
print(f"Waiting for approval: {pending[0]['value']}")

# Human approves (or rejects)
human_response = {"approved": True}   # or False

# Resume the graph from where it paused
result = agent.invoke(Command(resume=human_response), config)