Human-in-the-Loop

from langchain.agents import create_agent
from langchain.agents.middleware import HumanInTheLoopMiddleware
from langchain_ollama import ChatOllama
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import Command

agent = create_agent(
    ChatOllama(model="llama3.1:8b", temperature=0),
    tools=[docs_search, github_open_issue],
    middleware=[HumanInTheLoopMiddleware(interrupt_on={
        "github_open_issue": {"allowed_decisions": ["approve", "edit", "reject"]},
        "docs_search": False,
    })],
    checkpointer=InMemorySaver(),
)

config = {"configurable": {"thread_id": "report-42"}}
result = agent.invoke(
    {"messages": [("user", "The memory page says MessageWindowChatMemory keeps 10 messages.")]},
    config,
)
request = result["__interrupt__"][0].value   # {"action_requests": [...], "review_configs": [...]}

# ...later, when the reviewer has decided (same thread_id):
agent.invoke(Command(resume={"decisions": [{"type": "approve"}]}), config)

{
  "action_requests": [{
    "name": "github_open_issue",
    "args": {
      "page_path": "modules/ROOT/pages/ai/agents/memory.adoc",
      "problem": "States the wrong default window size for MessageWindowChatMemory.",
      "evidence": "https://docs.spring.io/spring-ai/reference/api/chat-memory.html"
    },
    "description": "Tool execution requires approval\n\nTool: github_open_issue\nArgs: {...}"
  }],
  "review_configs": [{
    "action_name": "github_open_issue",
    "allowed_decisions": ["approve", "edit", "reject"]
  }]
}

from typing import Literal, TypedDict

from langchain_ollama import ChatOllama
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt
from pydantic import BaseModel

llm = ChatOllama(model="llama3.1:8b", temperature=0)
ESCALATE_BELOW = 0.5         # too unsure to even propose an issue: a human investigates instead


class Assessment(BaseModel):
    page_is_wrong: bool
    confidence: float        # 0.0-1.0, the model's own estimate
    problem: str
    evidence: str


class ReportState(TypedDict):
    page_path: str
    user_report: str
    assessment: dict         # plain data, so the checkpointer can serialise it
    outcome: str


def assess(state: ReportState) -> dict:
    a = llm.with_structured_output(Assessment).invoke(
        f"User says {state['page_path']} is wrong: {state['user_report']}. Check the official "
        "sources; say whether the page is wrong, how confident you are (0-1), and the evidence.")
    return {"assessment": a.model_dump()}


def route(state: ReportState) -> Literal["approval", "escalate", "__end__"]:
    a = state["assessment"]
    if not a["page_is_wrong"]:
        return END
    return "approval" if a["confidence"] >= ESCALATE_BELOW else "escalate"


def approval(state: ReportState) -> Command[Literal["file_issue", "__end__"]]:
    a = state["assessment"]
    decision = interrupt({                          # pauses here; the value goes to the caller
        "question": "Open this GitHub issue?",
        "page_path": state["page_path"],
        **a,
    })
    if decision["type"] == "approve":
        return Command(goto="file_issue")
    if decision["type"] == "edit":
        return Command(goto="file_issue", update={"assessment": {**a, "problem": decision["problem"]}})
    return Command(goto=END, update={"outcome": f"rejected: {decision.get('reason', '')}"})


def file_issue(state: ReportState) -> dict:
    a = state["assessment"]
    result = github_open_issue.invoke(
        {"page_path": state["page_path"], "problem": a["problem"], "evidence": a["evidence"]})
    return {"outcome": str(result)}


def escalate(state: ReportState) -> dict:
    return {"outcome": "escalated to the docs maintainers' triage queue"}


builder = StateGraph(ReportState)
builder.add_node("assess", assess)
builder.add_node("approval", approval)
builder.add_node("file_issue", file_issue)
builder.add_node("escalate", escalate)
builder.add_edge(START, "assess")
builder.add_conditional_edges("assess", route)
builder.add_edge("file_issue", END)
builder.add_edge("escalate", END)
report_flow = builder.compile(checkpointer=InMemorySaver())

config = {"configurable": {"thread_id": "report-42"}}
paused = report_flow.invoke(
    {"page_path": "modules/ROOT/pages/ai/agents/memory.adoc",
     "user_report": "It says MessageWindowChatMemory keeps 10 messages by default."},
    config,
)
review_request = paused["__interrupt__"][0].value      # show this to the reviewer

finished = report_flow.invoke(Command(resume={"type": "approve"}), config)