LangGraph — Stateful Agent Workflows

from langchain_anthropic import ChatAnthropic
from langchain_openai import ChatOpenAI
from langchain_google_genai import ChatGoogleGenerativeAI

# אותו interface — ספקים שונים
claude = ChatAnthropic(model="claude-sonnet-4-5-20250514")
gpt = ChatOpenAI(model="gpt-4o")
gemini = ChatGoogleGenerativeAI(model="gemini-2.5-flash")

# כולם תומכים באותן פונקציות
response = claude.invoke("Explain agents in one sentence.")
print(response.content)
# "AI agents are software systems that use LLMs to
#  reason about and autonomously execute multi-step tasks."

from langchain_core.messages import (
    SystemMessage,
    HumanMessage,
    AIMessage,
    ToolMessage
)

messages = [
    SystemMessage(content="You are a helpful assistant."),
    HumanMessage(content="What's the weather in Tel Aviv?"),
    AIMessage(content="Let me check...", tool_calls=[{
        "id": "call_1",
        "name": "get_weather",
        "args": {"city": "Tel Aviv"}
    }]),
    ToolMessage(content='{"temp": 28, "condition": "sunny"}',
                tool_call_id="call_1"),
    AIMessage(content="It's 28C and sunny in Tel Aviv!")
]

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    # messages — רשימת הודעות עם reducer
    # add_messages מוסיף הודעות חדשות (לא מחליף)
    messages: Annotated[list, add_messages]

    # שדות נוספים לפי הצורך
    current_tool: str
    retry_count: int
    final_answer: str

from langchain_anthropic import ChatAnthropic

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

def call_llm(state: AgentState) -> dict:
    """Node: שולח הודעות ל-LLM ומקבל תשובה."""
    response = model.invoke(state["messages"])
    # מחזיר dict — add_messages reducer יוסיף את התשובה
    return {"messages": [response]}

def process_tool(state: AgentState) -> dict:
    """Node: מבצע tool call ומחזיר תוצאה."""
    last_message = state["messages"][-1]
    tool_call = last_message.tool_calls[0]

    # הרצת הכלי (פשוט לדוגמה)
    result = execute_tool(tool_call["name"], tool_call["args"])

    tool_msg = ToolMessage(
        content=str(result),
        tool_call_id=tool_call["id"]
    )
    return {"messages": [tool_msg]}

from langgraph.graph import StateGraph, START, END

# יצירת הגרף
workflow = StateGraph(AgentState)

# הוספת nodes
workflow.add_node("llm", call_llm)
workflow.add_node("tools", process_tool)

# Edge רגיל: START → llm
workflow.add_edge(START, "llm")

# Edge מותנה: llm → tools או END
def should_use_tool(state: AgentState) -> str:
    """Routing function: מחליטה לאן ללכת."""
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"  # יש tool call — לך ל-tools node
    return END          # אין — סיימנו

workflow.add_conditional_edges("llm", should_use_tool)

# Edge רגיל: tools → llm (חזרה ללולאה)
workflow.add_edge("tools", "llm")

# Compile!
app = workflow.compile()

# הרצה
result = app.invoke({
    "messages": [HumanMessage(content="What's 2+2?")],
    "current_tool": "",
    "retry_count": 0,
    "final_answer": ""
})

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

# State מינימלי — רק messages וסטטוס
class SimpleAgentState(TypedDict):
    messages: Annotated[list, add_messages]
    status: str  # "working" | "done" | "error"

from typing import TypedDict, Annotated, Optional
from langgraph.graph.message import add_messages

class WorkflowState(TypedDict):
    # === Core ===
    messages: Annotated[list, add_messages]

    # === Workflow tracking ===
    current_phase: str        # "research" | "draft" | "review" | "done"
    iteration_count: int      # מונע לולאות — עוצר ב-10
    error_count: int          # מונה שגיאות רצופות

    # === Data ===
    research_results: list    # ממצאי מחקר
    draft_content: str        # תוכן טיוטה
    human_feedback: str       # משוב אנושי

    # === Metadata ===
    user_id: str
    session_id: str
    started_at: str           # timestamp
    total_tokens_used: int    # מעקב עלויות

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages
import operator

def increment(current: int, update: int) -> int:
    """Reducer שמוסיף (לא מחליף) — לספירה."""
    return current + update

def keep_last_n(n: int):
    """Reducer factory — שומר רק N אחרונים ברשימה."""
    def reducer(current: list, update: list) -> list:
        combined = current + update
        return combined[-n:]  # שומרים רק N אחרונים
    return reducer

class SmartState(TypedDict):
    messages: Annotated[list, add_messages]
    # מוסיף (לא מחליף) — כל node שמחזיר tool_calls_count=1
    # יגדיל את המונה
    tool_calls_count: Annotated[int, increment]
    # שומר רק 5 תוצאות אחרונות — Sliding Window
    recent_results: Annotated[list, keep_last_n(5)]

from typing import TypedDict, Annotated
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
import ast
import operator

# === Step 1: הגדרת State ===
class AgentState(TypedDict):
    messages: Annotated[list, add_messages]

# === Step 2: הגדרת Tools ===
@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    weather_data = {
        "tel aviv": "28C, sunny, humidity 65%",
        "jerusalem": "22C, partly cloudy",
        "haifa": "25C, sunny, sea breeze",
    }
    return weather_data.get(city.lower(), f"No data for {city}")

@tool
def calculate(expression: str) -> str:
    """Calculate a mathematical expression.
    Supports: +, -, *, /, ** (power), % (modulo).
    Example: '15 * 340 / 100' or '2 ** 10'"""
    # Safe math evaluation using ast module
    allowed_operators = {
        ast.Add: operator.add,
        ast.Sub: operator.sub,
        ast.Mult: operator.mul,
        ast.Div: operator.truediv,
        ast.Pow: operator.pow,
        ast.Mod: operator.mod,
        ast.USub: operator.neg,
    }
    try:
        tree = ast.parse(expression, mode='eval')
        def safe_eval(node):
            if isinstance(node, ast.Expression):
                return safe_eval(node.body)
            elif isinstance(node, ast.Constant):
                return node.value
            elif isinstance(node, ast.BinOp):
                left = safe_eval(node.left)
                right = safe_eval(node.right)
                op = allowed_operators.get(type(node.op))
                if op is None:
                    raise ValueError(f"Unsupported operator")
                return op(left, right)
            elif isinstance(node, ast.UnaryOp):
                operand = safe_eval(node.operand)
                op = allowed_operators.get(type(node.op))
                if op is None:
                    raise ValueError(f"Unsupported operator")
                return op(operand)
            else:
                raise ValueError(f"Unsupported expression")
        result = safe_eval(tree)
        return str(result)
    except Exception as e:
        return f"Error: {e}"

tools = [get_weather, calculate]
tools_by_name = {t.name: t for t in tools}

# === Step 3: הגדרת Model עם tools ===
model = ChatAnthropic(model="claude-sonnet-4-5-20250514")
model_with_tools = model.bind_tools(tools)

# === Step 4: הגדרת Nodes ===
def call_model(state: AgentState) -> dict:
    """Node: קורא ל-LLM עם ההודעות הנוכחיות."""
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def call_tools(state: AgentState) -> dict:
    """Node: מריץ את ה-tools שהמודל ביקש."""
    last_message = state["messages"][-1]
    results = []
    for tc in last_message.tool_calls:
        tool_fn = tools_by_name[tc["name"]]
        result = tool_fn.invoke(tc["args"])
        results.append(
            ToolMessage(content=result, tool_call_id=tc["id"])
        )
    return {"messages": results}

# === Step 5: Routing Function ===
def should_continue(state: AgentState) -> str:
    last = state["messages"][-1]
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "tools"
    return END

# === Step 6: בניית הגרף ===
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", call_tools)
workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_edge("tools", "agent")

app = workflow.compile()

# === Step 7: הרצה ===
result = app.invoke({
    "messages": [
        HumanMessage(content="What's the weather in Tel Aviv? "
                     "Also, what's 15 * 340 / 100?")
    ]
})

# הדפסת התשובה האחרונה
print(result["messages"][-1].content)

from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import InMemorySaver

@tool
def get_weather(location: str) -> str:
    """Get the current weather for a location."""
    weather_data = {
        "tel aviv": "28C, sunny",
        "new york": "15C, cloudy",
        "london": "12C, rainy",
    }
    return weather_data.get(
        location.lower(),
        f"No weather data for {location}"
    )

@tool
def search_web(query: str) -> str:
    """Search the web for information."""
    return f"Search results for '{query}': [mock results]"

# === זהו — 3 שורות ===
agent = create_react_agent(
    model="anthropic:claude-sonnet-4-5-20250514",
    tools=[get_weather, search_web],
    prompt="You are a helpful assistant. Answer in Hebrew when asked in Hebrew.",
)

# הרצה עם memory
config = {"configurable": {"thread_id": "session-1"}}
result = agent.invoke(
    {"messages": [{"role": "user", "content": "מזג אוויר בתל אביב?"}]},
    config
)
print(result["messages"][-1].content)

# המשך שיחה — באותו thread
result2 = agent.invoke(
    {"messages": [{"role": "user", "content": "ומה לגבי לונדון?"}]},
    config
)
print(result2["messages"][-1].content)

from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import MemorySaver

agent = create_react_agent(
    model="anthropic:claude-sonnet-4-5-20250514",
    tools=[get_weather, search_web, calculate],

    # System prompt — ההוראות לסוכן
    prompt="You are a helpful assistant for Israeli businesses. "
           "Answer in the user's language. Be concise but thorough. "
           "Always verify data with tools before answering.",

    # Checkpointer — זיכרון בין שיחות
    checkpointer=MemorySaver(),

    # Response format — structured output
    response_format={
        "answer": "The main answer to the user's question",
        "sources": "List of sources or tools used",
        "confidence": "high, medium, or low"
    },

    # Pre-processing — פונקציה שרצה לפני כל LLM call
    state_modifier=lambda state: {
        **state,
        "messages": state["messages"][-20:]  # שומרים רק 20 הודעות אחרונות
    },
)

# הרצה עם config
config = {"configurable": {"thread_id": "biz-session-1"}}
result = agent.invoke(
    {"messages": [{"role": "user", "content": "מחיר Claude Sonnet?"}]},
    config
)
print(result["messages"][-1].content)

from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import StateGraph, START, END

# יוצרים checkpointer
memory = MemorySaver()

# בונים graph (כמו קודם)
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", call_tools)
workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_edge("tools", "agent")

# Compile עם checkpointer!
app = workflow.compile(checkpointer=memory)

# Thread 1 — שיחה ראשונה
config1 = {"configurable": {"thread_id": "user-123"}}
result1 = app.invoke(
    {"messages": [HumanMessage(content="My name is Nadav.")]},
    config1
)

# המשך שיחה — באותו thread
result2 = app.invoke(
    {"messages": [HumanMessage(content="What's my name?")]},
    config1
)
print(result2["messages"][-1].content)
# "Your name is Nadav."  -- הסוכן זוכר!

# Thread 2 — שיחה חדשה (לא זוכר)
config2 = {"configurable": {"thread_id": "user-456"}}
result3 = app.invoke(
    {"messages": [HumanMessage(content="What's my name?")]},
    config2
)
print(result3["messages"][-1].content)
# "I don't know your name."  -- thread חדש = clean slate

import sqlite3
from langgraph.checkpoint.sqlite import SqliteSaver

# חיבור ל-SQLite — הנתונים נשמרים בקובץ
conn = sqlite3.connect("agent_memory.db")
checkpointer = SqliteSaver(conn)

# Compile עם SQLite checkpointer
app = workflow.compile(checkpointer=checkpointer)

# עכשיו גם אחרי restart של התוכנית,
# הסוכן ימשיך מאיפה שעצר!
config = {"configurable": {"thread_id": "persistent-session"}}
result = app.invoke(
    {"messages": [HumanMessage(
        content="Remember: project deadline is April 1st"
    )]},
    config
)

# --- restart program ---
# הסוכן עדיין זוכר:
result = app.invoke(
    {"messages": [HumanMessage(content="When is the deadline?")]},
    config
)
# "The project deadline is April 1st."

from langgraph.checkpoint.memory import MemorySaver

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# הרצה רגילה
config = {"configurable": {"thread_id": "debug-session"}}
result = app.invoke(
    {"messages": [HumanMessage(content="Weather in Tel Aviv and calculate 15*23")]},
    config
)

# === Time-Travel: בדיקת כל checkpoint ===
# מקבלים את כל ה-checkpoints של ה-thread
checkpoints = list(
    memory.list(config)
)

print(f"Total checkpoints: {len(checkpoints)}")

for i, cp in enumerate(reversed(checkpoints)):
    state = cp.checkpoint
    print(f"\n--- Checkpoint {i} ---")
    print(f"  Node: {cp.metadata.get('source', 'unknown')}")
    print(f"  Messages count: {len(state.get('channel_values', {}).get('messages', []))}")
    # הצגת ההודעה האחרונה בכל checkpoint
    msgs = state.get("channel_values", {}).get("messages", [])
    if msgs:
        last = msgs[-1]
        content_preview = str(last.content)[:100] if hasattr(last, 'content') else str(last)[:100]
        print(f"  Last message: {content_preview}...")

# === Replay: הרצה מחדש מ-checkpoint ספציפי ===
# שימושי כשרוצים לבדוק "מה היה קורה אם..."
specific_checkpoint = checkpoints[2]  # חוזרים לצעד 2
result_replay = app.invoke(
    {"messages": [HumanMessage(content="Actually, check Jerusalem too")]},
    {
        "configurable": {
            "thread_id": "debug-session",
            "checkpoint_id": specific_checkpoint.config[
                "configurable"
            ]["checkpoint_id"]
        }
    }
)

from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
import asyncio

async def create_production_agent():
    """Setup מלא לפרודקשן עם PostgreSQL."""

    # חיבור ל-PostgreSQL
    DB_URI = "postgresql://user:pass@localhost:5432/agent_db"

    async with AsyncPostgresSaver.from_conn_string(DB_URI) as checkpointer:
        # יצירת הטבלאות (פעם ראשונה)
        await checkpointer.setup()

        # Compile עם PostgreSQL checkpointer
        app = workflow.compile(checkpointer=checkpointer)

        # הרצה — ה-state נשמר ב-PostgreSQL
        config = {"configurable": {"thread_id": "prod-user-123"}}
        result = await app.ainvoke(
            {"messages": [HumanMessage(content="Hello!")]},
            config
        )

        # אחרי restart — הסוכן ממשיך מאיפה שעצר!
        result2 = await app.ainvoke(
            {"messages": [HumanMessage(content="What did I say?")]},
            config
        )

        return result2

# הרצה
asyncio.run(create_production_agent())

from langgraph.types import Command, interrupt
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import StateGraph, START, END

class EmailState(TypedDict):
    messages: Annotated[list, add_messages]
    email_draft: str
    approved: bool

def draft_email(state: EmailState) -> dict:
    """Node: LLM כותב טיוטת מייל."""
    response = model.invoke(state["messages"])
    return {"email_draft": response.content}

def human_review(state: EmailState) -> Command:
    """Node: עוצר לאישור אנושי."""
    # interrupt() מציג את הטיוטה ומחכה לתשובה
    decision = interrupt({
        "draft": state["email_draft"],
        "action": "Please review this email. "
                  "Reply with 'approve' or provide edits."
    })

    if decision.get("approved"):
        # אושר — ממשיכים לשליחה
        edited = decision.get(
            "edited_draft", state["email_draft"]
        )
        return Command(
            update={"email_draft": edited, "approved": True},
            goto="send_email"
        )
    else:
        # נדחה — חוזרים לטיוטה
        return Command(
            update={"approved": False},
            goto=END
        )

def send_email(state: EmailState) -> dict:
    """Node: שולח את המייל (simulated)."""
    print(f"Sending email: {state['email_draft'][:100]}...")
    return {}

# בניית הגרף
workflow = StateGraph(EmailState)
workflow.add_node("draft", draft_email)
workflow.add_node("review", human_review)
workflow.add_node("send_email", send_email)

workflow.add_edge(START, "draft")
workflow.add_edge("draft", "review")
workflow.add_edge("send_email", END)

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# === שלב 1: הרצה ראשונה — הגרף יעצור ב-review ===
config = {"configurable": {"thread_id": "email-1"}}
result = app.invoke(
    {"messages": [HumanMessage(
        content="Draft an email to the team about the Q2 launch"
    )]},
    config
)
# result["__interrupt__"] מכיל את הטיוטה

# === שלב 2: אישור אנושי — הגרף ממשיך ===
result = app.invoke(
    Command(resume={"approved": True}),
    config
)
# "Sending email: ..."

import asyncio
from langgraph.types import Command, interrupt

def human_approval_with_timeout(state: dict) -> Command:
    """
    מבקש אישור אנושי.
    אם אין תשובה תוך timeout — פועל לפי default policy.
    """
    action = state.get("pending_action", {})
    risk_level = action.get("risk", "low")

    # low risk — אישור אוטומטי, לא צריך אדם
    if risk_level == "low":
        return Command(
            update={"approved": True},
            goto="execute_action"
        )

    # medium/high risk — מבקשים אישור
    decision = interrupt({
        "action": action,
        "risk_level": risk_level,
        "message": f"Action requires approval (risk: {risk_level})",
        "timeout_seconds": 300,  # 5 דקות
        "default_on_timeout": "reject" if risk_level == "high" else "approve"
    })

    if decision.get("approved"):
        return Command(
            update={"approved": True, "approved_by": decision.get("user", "unknown")},
            goto="execute_action"
        )
    else:
        reason = decision.get("reason", "No reason provided")
        return Command(
            update={"approved": False, "rejection_reason": reason},
            goto="notify_rejection"
        )

def multi_step_approval(state: dict) -> Command:
    """
    שרשרת אישורים:
    1. מנהל ישיר (כל פעולה)
    2. מנהל בכיר (מעל $1000)
    3. CFO (מעל $10000)
    """
    amount = state.get("amount", 0)
    approvals_needed = ["manager"]
    if amount > 1000:
        approvals_needed.append("senior_manager")
    if amount > 10000:
        approvals_needed.append("cfo")

    current_approvals = state.get("approvals", [])
    remaining = [
        a for a in approvals_needed
        if a not in current_approvals
    ]

    if not remaining:
        # כל האישורים התקבלו
        return Command(
            update={"fully_approved": True},
            goto="execute_action"
        )

    next_approver = remaining[0]
    decision = interrupt({
        "requires_approval_from": next_approver,
        "amount": amount,
        "current_approvals": current_approvals,
        "remaining_approvals": remaining[1:],
        "action_summary": state.get("action_summary", "")
    })

    if decision.get("approved"):
        updated_approvals = current_approvals + [next_approver]
        return Command(
            update={"approvals": updated_approvals},
            goto="multi_step_approval"  # חוזר לבדוק אם צריך עוד
        )
    else:
        return Command(
            update={"rejected_by": next_approver},
            goto="notify_rejection"
        )

from typing import Literal
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.types import Command

class TeamState(TypedDict):
    messages: Annotated[list, add_messages]
    next_worker: str
    research_output: str
    final_output: str

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

def supervisor(state: TeamState) -> Command:
    """Supervisor: מחליט מי עובד הבא."""
    sys_msg = SystemMessage(content="""You are a project supervisor.
Based on the conversation, decide the next step:
- If research is needed, respond with: ROUTE:researcher
- If writing is needed (after research), respond with: ROUTE:writer
- If the task is complete, respond with: ROUTE:FINISH

Always start with researcher, then writer, then FINISH.""")

    response = model.invoke([sys_msg] + state["messages"])
    content = response.content

    if "ROUTE:researcher" in content:
        return Command(
            update={"messages": [response]},
            goto="researcher"
        )
    elif "ROUTE:writer" in content:
        return Command(
            update={"messages": [response]},
            goto="writer"
        )
    else:
        return Command(
            update={"messages": [response]},
            goto=END
        )

def researcher(state: TeamState) -> dict:
    """Researcher: מבצע research ומחזיר ממצאים."""
    sys_msg = SystemMessage(content="""You are a research analyst.
Research the topic thoroughly and provide key findings,
data points, and insights. Be factual and detailed.""")

    response = model.invoke([sys_msg] + state["messages"])
    return {
        "messages": [response],
        "research_output": response.content
    }

def writer(state: TeamState) -> dict:
    """Writer: כותב תוכן בהתבסס על ה-research."""
    sys_msg = SystemMessage(content=f"""You are a professional writer.
Based on this research:
{state.get('research_output', 'No research available')}

Write a compelling, well-structured article. Use Hebrew if
the original request was in Hebrew.""")

    response = model.invoke([sys_msg] + state["messages"])
    return {
        "messages": [response],
        "final_output": response.content
    }

# בניית הגרף
workflow = StateGraph(TeamState)
workflow.add_node("supervisor", supervisor)
workflow.add_node("researcher", researcher)
workflow.add_node("writer", writer)

workflow.add_edge(START, "supervisor")
workflow.add_edge("researcher", "supervisor")
workflow.add_edge("writer", "supervisor")

app = workflow.compile()

# הרצה
result = app.invoke({
    "messages": [HumanMessage(
        content="Write an article about AI agents in Israeli startups"
    )]
})

print(result["final_output"])

from langgraph.types import Command

class SwarmState(TypedDict):
    messages: Annotated[list, add_messages]
    current_agent: str
    handoff_count: int  # מגביל — מונע לולאות

def sales_agent(state: SwarmState) -> Command:
    """Sales agent — מטפל בשאלות מכירה."""
    sys_msg = SystemMessage(content="""You are a sales agent.
If the user asks about pricing or products, help them.
If they ask about technical issues, hand off to: HANDOFF:support
If they ask about billing, hand off to: HANDOFF:billing
Otherwise, respond directly.""")

    response = model.invoke([sys_msg] + state["messages"])
    content = response.content

    # בדיקת handoff
    if "HANDOFF:support" in content:
        return Command(
            update={
                "messages": [response],
                "current_agent": "support",
                "handoff_count": 1
            },
            goto="support_agent"
        )
    elif "HANDOFF:billing" in content:
        return Command(
            update={
                "messages": [response],
                "current_agent": "billing",
                "handoff_count": 1
            },
            goto="billing_agent"
        )

    # אין handoff — עונה ישירות
    return Command(
        update={"messages": [response]},
        goto=END
    )

def support_agent(state: SwarmState) -> Command:
    """Support agent — מטפל בבעיות טכניות."""
    # מגבלת handoffs — מונע Ping-Pong בין סוכנים
    if state.get("handoff_count", 0) >= 3:
        return Command(
            update={"messages": [
                AIMessage(content="מעביר לנציג אנושי — יותר מדי העברות.")
            ]},
            goto=END
        )

    sys_msg = SystemMessage(content="""You are a technical support agent.
Help with technical issues. If you can't help and it's a billing
issue, hand off to: HANDOFF:billing""")

    response = model.invoke([sys_msg] + state["messages"])
    content = response.content

    if "HANDOFF:billing" in content:
        return Command(
            update={
                "messages": [response],
                "current_agent": "billing",
                "handoff_count": 1
            },
            goto="billing_agent"
        )

    return Command(
        update={"messages": [response]},
        goto=END
    )

# בניית הגרף
workflow = StateGraph(SwarmState)
workflow.add_node("sales_agent", sales_agent)
workflow.add_node("support_agent", support_agent)
workflow.add_node("billing_agent", billing_agent)  # דומה ל-support

# Entry point — תמיד מתחילים ב-sales
workflow.add_edge(START, "sales_agent")

app = workflow.compile(checkpointer=MemorySaver())

# Option 1: Environment variables (מומלץ)
# ב-.env:
# LANGSMITH_API_KEY=lsv2_pt_...
# LANGSMITH_TRACING=true
# LANGSMITH_PROJECT=my-agent-project

# Option 2: בקוד
import os
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = "lsv2_pt_..."
os.environ["LANGSMITH_PROJECT"] = "my-agent-project"

# זהו! כל LangGraph/LangChain call עכשיו מתועד
# פתחו https://smith.langchain.com לראות traces

from langsmith import traceable

@traceable(
    name="customer_support_agent",
    tags=["production", "tier-1"],
    metadata={
        "team": "support",
        "version": "1.3.2",
    }
)
def run_support_agent(query: str, user_id: str) -> dict:
    """Agent עם metadata מלא ב-LangSmith."""
    config = {
        "configurable": {"thread_id": f"support-{user_id}"},
        # Metadata שיופיע ב-LangSmith
        "metadata": {
            "user_id": user_id,
            "query_length": len(query),
            "language": "he" if any(
                "\u0590" <= c <= "\u05FF" for c in query
            ) else "en",
        },
        # Tags — לסינון ב-Dashboard
        "tags": [
            f"user:{user_id}",
            "channel:web",
        ],
    }

    result = app.invoke(
        {"messages": [HumanMessage(content=query)]},
        config
    )

    return {
        "response": result["messages"][-1].content,
        "steps": len(result["messages"]),
    }

# עכשיו ב-LangSmith אפשר לסנן:
# - לפי user_id
# - לפי שפה (עברית/אנגלית)
# - לפי channel
# - לפי version

from langsmith import Client
from langsmith.evaluation import evaluate

client = Client()

# Golden dataset — 20+ test cases עם תשובות מצופות
# יוצרים פעם אחת, מעדכנים כשמוסיפים features
DATASET_NAME = "weather-agent-golden-v2"

def weekly_quality_check():
    """הרצה שבועית — מוודאת שהסוכן עדיין עובד."""

    def agent_fn(inputs: dict) -> dict:
        result = app.invoke({
            "messages": [HumanMessage(content=inputs["query"])]
        })
        return {"output": result["messages"][-1].content}

    # בודקים: האם הסוכן השתמש בכלי הנכון?
    def check_tool_usage(run, example):
        expected_tool = example.outputs.get("expected_tool")
        if not expected_tool:
            return {"key": "tool_check", "score": True}
        trace_steps = str(run.outputs)
        used_tool = expected_tool.lower() in trace_steps.lower()
        return {"key": "tool_check", "score": used_tool}

    # בודקים: האם התשובה בשפה הנכונה?
    def check_language(run, example):
        expected_lang = example.outputs.get("expected_language", "en")
        output = run.outputs.get("output", "")
        has_hebrew = any("\u0590" <= c <= "\u05FF" for c in output)
        if expected_lang == "he":
            return {"key": "correct_language", "score": has_hebrew}
        return {"key": "correct_language", "score": not has_hebrew}

    results = evaluate(
        agent_fn,
        data=DATASET_NAME,
        evaluators=[check_tool_usage, check_language],
    )

    pass_rate = results.summary_results.get("tool_check", 0)
    print(f"Weekly quality check pass rate: {pass_rate:.0%}")

    if pass_rate < 0.8:
        print("ALERT: Agent quality dropped below 80%!")
        # בפרודקשן: שליחת alert ל-Slack/email

weekly_quality_check()

from langsmith import Client
from langsmith.evaluation import evaluate

client = Client()

# יצירת dataset עם test cases
dataset = client.create_dataset("weather-agent-tests")
client.create_examples(
    inputs=[
        {"query": "What's the weather in Tel Aviv?"},
        {"query": "Is it raining in London?"},
        {"query": "Compare weather in NYC and SF"},
    ],
    outputs=[
        {"must_contain": "Tel Aviv"},
        {"must_contain": "London"},
        {"must_contain": ["NYC", "SF"]},
    ],
    dataset_id=dataset.id
)

# פונקציית evaluation
def run_agent(inputs: dict) -> dict:
    result = app.invoke({
        "messages": [HumanMessage(content=inputs["query"])]
    })
    return {"output": result["messages"][-1].content}

# הרצת evaluation
results = evaluate(
    run_agent,
    data=dataset.name,
    evaluators=[
        lambda run, example: {
            "key": "contains_expected",
            "score": all(
                term in run.outputs["output"]
                for term in (
                    [example.outputs["must_contain"]]
                    if isinstance(
                        example.outputs["must_contain"], str
                    )
                    else example.outputs["must_contain"]
                )
            )
        }
    ]
)

print(f"Pass rate: {results.summary_results['contains_expected']}")

from fastapi import FastAPI
from langserve import add_routes

# ה-agent שבניתם
app_agent = workflow.compile(checkpointer=memory)

# FastAPI app
api = FastAPI(title="AI Agent API")

# LangServe מוסיף endpoints אוטומטיים
add_routes(api, app_agent, path="/agent")

# עכשיו יש לכם:
# POST /agent/invoke    — הרצה בודדת
# POST /agent/stream    — streaming
# POST /agent/batch     — הרצה מרובה
# GET  /agent/playground — UI לבדיקה

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(api, host="0.0.0.0", port=8000)

from IPython.display import Image, display

# ב-Jupyter Notebook / IPython
app = workflow.compile(checkpointer=memory)

# מייצר תמונת PNG של הגרף
graph_image = app.get_graph().draw_mermaid_png()
display(Image(graph_image))

# אלטרנטיבה: Mermaid text (אפשר להדביק ב-mermaid.live)
mermaid_text = app.get_graph().draw_mermaid()
print(mermaid_text)
# graph LR
#   __start__ --> agent
#   agent --> tools
#   agent --> __end__
#   tools --> agent

config = {"configurable": {"thread_id": "debug-1"}}

# stream_mode="updates" — רואים רק את מה שהשתנה בכל צעד
for event in app.stream(
    {"messages": [HumanMessage(content="Weather in Tel Aviv?")]},
    config,
    stream_mode="updates"
):
    for node_name, state_update in event.items():
        print(f"\n{'='*50}")
        print(f"NODE: {node_name}")
        print(f"{'='*50}")

        # הצגת הודעות חדשות בלבד
        if "messages" in state_update:
            for msg in state_update["messages"]:
                msg_type = type(msg).__name__
                content = str(msg.content)[:200]
                print(f"  [{msg_type}] {content}")

                # הצגת tool calls אם יש
                if hasattr(msg, "tool_calls") and msg.tool_calls:
                    for tc in msg.tool_calls:
                        print(f"    -> Tool: {tc['name']}({tc['args']})")

# במקום להריץ את כל הגרף, בודקים node אחד
test_state = {
    "messages": [
        HumanMessage(content="What's 15 * 23?"),
        # מדמים תשובת LLM עם tool call
    ],
    "retry_count": 0,
}

# קוראים ישירות ל-node function
result = call_model(test_state)
print("Model response:", result)

# בודקים את ה-routing function
route = should_continue(test_state)
print(f"Route decision: {route}")

# בודקים tool execution
tool_state = {
    "messages": [
        # הודעה עם tool_calls
        AIMessage(content="", tool_calls=[{
            "id": "test-1",
            "name": "get_weather",
            "args": {"city": "Tel Aviv"}
        }])
    ]
}
tool_result = call_tools(tool_state)
print("Tool result:", tool_result)

def should_continue_safe(state: AgentState) -> str:
    """Routing function עם הגנה מלולאות."""
    last = state["messages"][-1]
    retry_count = state.get("retry_count", 0)

    # הגנה 1: מגבלת iterations
    if retry_count >= 10:
        print(f"[SAFETY] Max iterations ({retry_count}) reached. Stopping.")
        return END

    # הגנה 2: זיהוי חזרה על אותו tool call
    if len(state["messages"]) >= 4:
        recent_tool_calls = []
        for msg in state["messages"][-6:]:
            if hasattr(msg, "tool_calls") and msg.tool_calls:
                for tc in msg.tool_calls:
                    recent_tool_calls.append(
                        f"{tc['name']}:{sorted(tc['args'].items())}"
                    )

        # אם אותו tool call חוזר 3 פעמים — לולאה
        from collections import Counter
        counts = Counter(recent_tool_calls)
        for call, count in counts.items():
            if count >= 3:
                print(f"[SAFETY] Loop detected: {call} called {count} times")
                return END

    # הגנה 3: מגבלת טוקנים (אם עוקבים)
    total_tokens = state.get("total_tokens_used", 0)
    if total_tokens > 50000:
        print(f"[SAFETY] Token budget exceeded: {total_tokens}")
        return END

    # לוגיקה רגילה
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "tools"
    return END