Jak se AI agenti stávají autonomnějšími a schopnějšími, jejich role se mění od pasivních asistentů k proaktivním aktérům.Dnešní velké jazykové modely (LLM) nejen vytvářejí text – vykonávají úkoly, přistupují k rozhraním API, modifikují databáze a dokonce řídí infrastrukturu. Agenti AI provádějí akce, které byly kdysi vyhrazeny výhradně pro lidské uživatele, ať už se jedná o naplánování schůzky, nasazení služby nebo přístup k citlivému dokumentu. , , Jeden halucinovaný příkaz, nepochopený výzva nebo příliš široké oprávnění může vést k úniku dat, porušení shody nebo poškození systémů. When agents operate without guardrails they can inadvertently make harmful or unauthorized decisions To je důvod, proč začlenit workflows is essential for agent safety and accountability. human-in-the-loop (HITL) je rámec navržený tak, aby umožňoval agentům AI schopnost citlivé reakce a zároveň umožňují . Přístupová žádost Permit.io MCP request humans to remain the final decision-makers Přístupová žádost Permit.io MCP Vybudováno je a integrované do populárních agentových rámců, jako jsou a Tento systém vám umožní vložit schvalovací pracovní postupy přímo do vašich aplikací poháněných LLM. Povolení.cz LangChain LangGraph V tomto tutoriálu se naučíte: Proč je delegování citlivých oprávnění lidem kritické pro důvěryhodnou AI, Jak Permit.io Model Context Protocol (MCP) umožňuje pracovní postupy přístupových požadavků, Jak vytvořit systém v reálném světě, který kombinuje inteligenci LLM s lidským dohledem – pomocí funkce interrupt() společnosti LangGraph. Než se ponoříme do našich kroků demo aplikace a implementace, pojďme stručně diskutovat o důležitosti přenesení oprávnění AI na lidi. Proč je udělování povolení lidem kritické Agenty umělé inteligence jsou mocné, ale jak všichni víme, nejsou neomylné. Následují pokyny, ale nerozumí kontextu jako lidé.Vytvářejí odpovědi, ale nemohou posoudit důsledky.A když jsou tito agenti integrováni do reálných systémů – bankovních nástrojů, interních tabulek, kontrol infrastruktury – je to nebezpečná mezera. V tomto kontextu je vše, co může jít špatně, poměrně jasné: Nadměrně povolující agenti: LLM mohou mít přístup k nástrojům, které by se neměly dotýkat, a to buď designem, nebo náhodou. Hallucinované volání nástrojů: Agenti mohou vytvářet příkazy, argumenty nebo ID, které nikdy neexistovaly. Nedostatek auditovatelnosti: Bez lidských kontrolních bodů není jasný záznam o tom, kdo schválil co nebo proč. Delegation is the solution. Namísto toho, abychom poskytli agentům nekontrolovanou sílu, dáváme jim protokol: „Můžete se ptát, ale člověk rozhoduje.“ Představením schválení na klíčových rozhodovacích místech, získáte: human-in-the-loop (HITL) Zabraňte nevratným činnostem dříve, než k nim dojde. Zodpovědnost: Vyžaduje výslovnou lidskou registraci pro operace s vysokými sázkami. Ovládání: Nechte lidi nastavit pravidla – kdo může schválit, co může být schváleno a kdy. Jaký je rozdíl mezi agentem Něco a agent Aby něco udělali. dělat Žádost A je to přesně to, co Přístupová žádost MCP umožňuje. Povolení.cz Přístupová žádost Permit.io MCP Je klíčovou součástí Modelový kontextový protokol (MCP) – specifikace, která poskytuje agentům umělé inteligence bezpečný přístup k nástrojům a zdrojům. The Access Request MCP Povolení.cz Přemýšlejte o tom jako o mostě mezi a . LLMs that want to act humans who need control Co dělá Permit's Access Request MCP umožňuje agentům AI: Požádat o přístup k omezeným zdrojům (např. „Mohu získat přístup k této restauraci?“) Požádat o povolení k provádění citlivých operací (např. „Mohu si objednat toto omezené jídlo?“) Čekání na lidský vstup před zahájením práce – prostřednictvím mechanismu interrupt() společnosti LangGraph Logování žádosti a rozhodnutí o auditu a shodě Za scénami se používá ‚s autorizační schopnosti postavené na podporu: Povolení.cz ReBAC (Relationship-Based Access Control) a další politiky Fine-grained Authorization (FGA). Schválení pracovních postupů Elementy podporované politikou, které fungují v kontextech UI, API a LLM ReBAC Fine Grained Authorization (FGA) – povolení pro jemné zrno Schválení pracovních postupů Politicky podpořené prvky Plug-and-play s LangChain a LangGraph MCP je integrován přímo do a Ekologický systém : LangChain MCP Adapter LangGraph Povolit prvky můžete vystavit jako nástroje kompatibilní s LangGraphem. Agent můžete pozastavit pomocí funkce interrupt() při provádění citlivých akcí. Můžete pokračovat ve výkonu na základě skutečných lidských rozhodnutí. Je to nejjednodušší způsob, jak Není potřeba žádný custom backend. inject human judgment into AI behavior Pochopení implementace a jejích výhod, pojďme se dostat do naší demo aplikace. Co budeme stavět - Přehled demo aplikací V tomto tutoriálu vytvoříme ve kterém se A ty. real-time approval workflow AI agent can request access or perform sensitive actions, but only a human can approve Scénář: Rodinný potravinový systém Chcete-li zjistit, jak může Permit MCP pomoci povolit pracovní postup HITL v uživatelské aplikaci, budeme modelovat Pro jednu rodinu: food ordering system Rodiče mají přístup ke všem restauracím a pokrmům. Děti si mohou prohlížet veřejné předměty, ale musí požádat o přístup do omezených restaurací nebo drahých jídel. Když dítě podá žádost, rodič ji obdrží k přezkumu a musí ji výslovně schválit nebo zamítnout před zahájením akce. Tento případ použití odráží společný vzorec: „Agenti mohou pomáhat, ale lidé rozhodují.“ Technický Stack Tuto funkci HITL-enabled agent vytvoříme pomocí: Permit.io - Zpracovává oprávnění, role, zásady a schválení Povolení serveru MCP - Exponuje Povolení pracovních postupů jako nástrojů, které může agent používat LangChain MCP Adapters - Bridges Umožňuje MCP nástroje do LangGraph & LangChain LangGraph - Orchestruje pracovní postup agenta s podporou interrupt() Gemini 2.0 Flash - lehký, multimodální LLM používaný jako argumentovací motor agenta Python - lepidlo, které drží všechno dohromady Získáte pracovní systém, ve kterém mohou agenti spolupracovat s lidmi, aby zajistili bezpečné, záměrné chování – pomocí skutečných politik, skutečných nástrojů a schválení v reálném čase. A repository with the full code for this application is available here. Repozitář s úplným kódem pro tuto aplikaci je k dispozici zde. Krok za krokem tutoriál V této sekci se podíváme na to, jak implementovat plně funkční lidský agentový systém pomocí A také Langgraph. Povolení.cz Budeme se zabývat: Modelování povolení s povolením Nastavení povolení MCP serveru Vytvoření LangGraph + LangChain MCP klienta Přidání Human-in-the-Loop s interrupt() Spuštění celého pracovního postupu Pojďme se do toho dostat - Modelování povolení s povolením Začneme definováním pravidel přístupu vašeho systému uvnitř To vám umožní modelovat, které uživatelé mohou dělat co a jaké akce by měly spustit tok schválení. Povolení.io Dashboard Create a ReBAC Resource Navigace na Stránka z sidebaru, pak: Policy Klikněte na záložku Resources Klikněte na Vytvořit zdroj Name the resource: restaurants Under , define two roles: ReBAC Options parent child-can-order Klikněte na Save Nyní jděte na Tab a přiřazení oprávnění: Policy Editor Rodiče: plný přístup (vytvářet, číst, aktualizovat, smazat) Dětský řád: číst Set Up Permit Elements Jděte na Závěrečná tabulka z bočního okna. v section, click . Elements User Management Create Element Configure the element as follows: : Restaurant Requests Name : ReBAC Resource Roles Configure elements based on : restaurants Resource Type Role permission levels Level 1 – Workspace Owner: parent Assignable Roles: child-can-order Klikněte na Vytvořit Na nově vytvořené kartě prvků klikněte na tlačítko Získat kód a zaznamenávejte konfig ID: restaurace-žádosti. Add Operation Approval Elements Create a new element: Operation Approval : Dish Approval Name : restaurants Resource Type Klikněte na Vytvořit Then create an element: Approval Management : Dish Requests Name Klikněte na Get Code a zkopírujte config ID: dish-requests. Add Test Users & Resource Instances Navigace do adresáře > Instance Click Add Instance : restaurants Resource Type : Instance Key pizza-palace : Default Tenant (or your working tenant) Tenant Přechod na uživatelskou kartu Click Add User : Key joe : Instance Access restaurants:pizza-palace#parent Click Save Create another user with the key henry Don’t assign a role Jakmile je povolení nakonfigurováno, jsme připraveni klonovat server MCP a připojit vaše zásady k pracovnímu agentu. Nastavení povolení MCP serveru S politikami modelovanými v příručce Povolení je čas je oživit nastavením — místní služba, která vystavuje vaše žádosti o přístup a toky schválení jako nástroje, které může agent AI použít. Permit MCP server Clone and Install the MCP Server Začněte klonováním úložiště serveru MCP a nastavením virtuálního prostředí. git clone <https://github.com/permitio/permit-mcp> cd permit-mcp # Create virtual environment, activate it and install dependencies uv venv source .venv/bin/activate # For Windows: .venv\\Scripts\\activate uv pip install -e . Add Environment Configuration Vytvořte A souboru u kořene projektu na základě poskytnutého , a vyplňte ji správnými hodnotami z nastavení Povolení: .env .env.example bash CopyEdit RESOURCE_KEY=restaurants ACCESS_ELEMENTS_CONFIG_ID=restaurant-requests OPERATION_ELEMENTS_CONFIG_ID=dish-requests TENANT= # e.g. default LOCAL_PDP_URL= PERMIT_API_KEY= PROJECT_ID= ENV_ID= Tyto hodnoty můžete získat pomocí následujících zdrojů: Místní_PDP_URL Povolení API - klíč Projekt - ID ČSSD - ID ☀️ Poznámka: Používáme pro tento výukový program na podporu hodnocení ReBAC a testování s nízkou latencí, offline. Povolení pro místní PDP (Policy Decision Point) Start the Server S tím vším na místě, můžete nyní spustit server MCP lokálně: uv run -m src.permit_mcp Jakmile je server spuštěn, vystaví vaše konfigurované prvky oprávnění (žádost o přístup, řízení schválení atd.) jako nástroje, které může agent volat prostřednictvím protokolu MCP. Vytvoření LangGraph + LangChain MCP klienta Nyní, když je server Permit MCP nastaven a spuštěn, vytvoříme klienta AI agenta, který s ním může komunikovat. Použijte Gemini-powered LLM rozhodnout, jaké kroky podniknoutDynamicky volat MCP nástroje, jako je request_access, approve_operation_approval, atd. Spuštění plně v rámci pracovního postupu LangGraph Pause pro lidský přezkum pomocí interrupt() (v další části) Pojďme spojit body. Install Required Dependencies Uvnitř adresáře projektu MCP nainstalujte potřebné balíčky: uv add langchain-mcp-adapters langgraph langchain-google-genai To vám dává: langchain-mcp-adaptéry: Automaticky převádí nástroje Permit MCP na nástroje kompatibilní s LangGraphem langgraph: pro orchestrování pracovních postupů založených na grafu langchain-google-genai: Pro interakci s Gemini 2.0 Flash Add Google API Key Budete potřebovat API klíč Používejte Gemini Google ve studiu Add the key to your souboru : .env GOOGLE_API_KEY=your-key-here Build the MCP Client Vytvořte soubor s názvem ve vašem projektu Root. client.py Tento soubor rozdělíme na logické bloky: Imports and Setup Start by importing dependencies and loading environment variables: import os from typing_extensions import TypedDict, Literal, Annotated from dotenv import load_dotenv from langchain_google_genai import ChatGoogleGenerativeAI from langgraph.graph import StateGraph, START, END from langgraph.types import Command, interrupt from langgraph.checkpoint.memory import MemorySaver from langgraph.prebuilt import ToolNode from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client from langchain_mcp_adapters.tools import load_mcp_tools import asyncio from langgraph.graph.message import add_messages Then, load the environment and set up your Gemini LLM: load_dotenv() global_llm_with_tools = None llm = ChatGoogleGenerativeAI( model="gemini-2.0-flash", google_api_key=os.getenv('GOOGLE_API_KEY') ) Tell LangGraph how to communicate with the running MCP server: Configure MCP Server Parameters server_params = StdioServerParameters( command="python", args=["src/permit_mcp/server.py"], ) Stanovení stavu sdíleného agenta: class State(TypedDict): messages: Annotated[list, add_messages] and the : Define Workflow Nodes graph builder Here’s the logic to route between calling the LLM and invoking tools: async def call_llm(state): response = await global_llm_with_tools.ainvoke(state["messages"]) return {"messages": [response]} def route_after_llm(state) -> Literal[END, "run_tool"]: return END if len(state["messages"][-1].tool_calls) == 0 else "run_tool" async def setup_graph(tools): builder = StateGraph(State) run_tool = ToolNode(tools) builder.add_node(call_llm) builder.add_node('run_tool', run_tool) builder.add_edge(START, "call_llm") builder.add_conditional_edges("call_llm", route_after_llm) builder.add_edge("run_tool", "call_llm") memory = MemorySaver() return builder.compile(checkpointer=memory) Ve výše uvedeném kódu jsme definovali LLM uzel a jeho podmíněný okraj, který vede na Node, pokud existuje volání nástroje ve zprávě stavu, nebo končí graf. Také jsme definovali funkci pro nastavení a kompilaci grafu pomocí kontrolního ukazatele v paměti. run_tool Dále přidejte následující řádek kódu pro streamování odpovědi z grafu a přidejte interaktivní chatu, která bude spuštěna, dokud není výslovně ukončena. and an : Stream Output and Handle Chat Input, infinite loop for user interaction async def stream_responses(graph, config, invokeWith): async for event in graph.astream(invokeWith, config, stream_mode='updates'): for key, value in event.items(): if key == 'call_llm': content = value["messages"][-1].content if content: print('\\n' + ", ".join(content) if isinstance(content, list) else content) async def chat_loop(graph): while True: try: user_input = input("\\nQuery: ").strip() if user_input in ["quit", "exit", "q"]: print("Goodbye!") break sys_m = """ Always provide the resource instance key during tool calls, as the ReBAC authorization model is being used. To obtain the resource instance key, use the list_resource_instances tool to view available resource instances. Always parse the provided data before displaying it. If the user has initially provided their ID, use that for subsequent tool calls without asking them again. """ invokeWith = {"messages": [ {"role": "user", "content": sys_m + '\\n\\n' + user_input}]} config = {"configurable": {"thread_id": "1"}} await stream_responses(graph, config, invokeWith) except Exception as e: print(f"Error: {e}") Final Assembly Add the main entry point where we will convert the Permit MCP server tool to LangGraph-compatible tools, bind our LLM to the resulting tools, set up the graph, draw it to a file, and fire up the chat loop: python CopyEdit async def main(): async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as session: await session.initialize() tools = await load_mcp_tools(session) llm_with_tools = llm.bind_tools(tools) graph = await setup_graph(tools) global global_llm_with_tools global_llm_with_tools = llm_with_tools with open("workflow_graph.png", "wb") as f: f.write(graph.get_graph().draw_mermaid_png()) await chat_loop(graph) if __name__ == "__main__": asyncio.run(main()) Lastly, Run the Client Jakmile vše uložíte, spustíte klienta: uv run client.py Po spuštění se zobrazí nový obrazový soubor s názvem bude vytvořen, což ukazuje graf. workflow_graph.png Jakmile je vše nastaveno, můžeme nyní specifikovat dotazy, jako je tento: Query: My user id is henry, request access to pizza palace with the reason: I am now 18, and the role child-can-order Query: My user id is joe, list all access requests Your agent is now able to call MCP tools dynamically! Přidání human-in-the-loop s interrupt() S vaším klientem MCP poháněným technologií LangGraph je nyní možné povolovat nástroje povolení automaticky. jako udělení přístupu k omezenému zdroji nebo schválení vysoce rizikové operace? sensitive, To je místo, kde LangGraph Stává se užitečným. interrupt() Nyní přidáme a interceptovat a pozastavit pracovní postup pokaždé, když se agent pokusí vyvolat kritické nástroje, jako jsou: human approval node Přihláška - přihláška - žádost schválení_operation_approval Člověk bude požádán o Nástroj volá předtím, než agent pokračuje. manually approve or deny Define the Human Review Node Na vrcholu vašeho Archiv (předtím než Přidejte následující funkci: client.py setup_graph async def human_review_node(state) -> Command[Literal["call_llm", "run_tool"]]: """Handle human review process.""" last_message = state["messages"][-1] tool_call = last_message.tool_calls[-1] high_risk_tools = ['approve_access_request', 'approve_operation_approval'] if tool_call["name"] not in high_risk_tools: return Command(goto="run_tool") human_review = interrupt({ "question": "Do you approve this tool call? (yes/no)", "tool_call": tool_call, }) review_action = human_review["action"] if review_action == "yes": return Command(goto="run_tool") return Command(goto="call_llm", update={"messages": [{ "role": "tool", "content": f"The user declined your request to execute the {tool_call.get('name', 'Unknown')} tool, with arguments {tool_call.get('args', 'N/A')}", "name": tool_call["name"], "tool_call_id": tool_call["id"], }]}) Tento uzel zkontroluje, zda je volaný nástroj považován za „vysoké riziko“. Update Graph Routing Změňte to funkce tak, že nástroj volá trasu do lidského hodnocení uzlu namísto spuštění okamžitě: route_after_llm def route_after_llm(state) -> Literal[END, "human_review_node"]: """Route logic after LLM processing.""" return END if len(state["messages"][-1].tool_calls) == 0 else "human_review_node" Wire in the HITL Node Aktualizace na Funkce Přidat jako uzel v grafu: setup_graph human_review_node async def setup_graph(tools): builder = StateGraph(State) run_tool = ToolNode(tools) builder.add_node(call_llm) builder.add_node('run_tool', run_tool) builder.add_node(human_review_node) # Add the interrupt node here builder.add_edge(START, "call_llm") builder.add_conditional_edges("call_llm", route_after_llm) builder.add_edge("run_tool", "call_llm") memory = MemorySaver() return builder.compile(checkpointer=memory) Handle Human Input During Runtime Konečně zlepšíme vaše funkce detekovat, kdy je graf přerušen, vyzvat k rozhodnutí, a pokračovat s lidským vstupem pomocí . stream_responses Command(resume={"action": user_input}) Po spuštění klienta by graf neměl vypadat takto: Po spuštění klienta, grafický diagram ( ) bude nyní zahrnovat lidský přezkumný uzel mezi fázemi LLM a implementací nástrojů: workflow_graph.png To zajišťuje, že kdykoli se agent pokusí učinit rozhodnutí, které by mohlo změnit oprávnění nebo obcházet omezení. you remain in control Díky tomu jste úspěšně přidali lidský dohled do svého agenta AI, aniž byste přepisovali své nástroje nebo backendovou logiku. Závěr V tomto tutoriálu jsme vybudovali bezpečného, lidsky vědomého agenta AI pomocí . Permit.io’s Access Request MCP , , LangGraph , a LangChain MCP Adapters Přístupová žádost Permit.io MCP dlouhý LangChain MCP Adapters Namísto toho, aby agent pracoval bez kontroly, dali jsme mu moc Přístup a Stejně jako zodpovědný člen týmu. request defer critical decisions to human users, We covered: Jak modelovat oprávnění a toky schválení pomocí prvků oprávnění a ReBAC Jak vystavit tyto toky prostřednictvím serveru Permit MCP Jak vytvořit klient poháněný LangGraphem, který tyto nástroje využívá přirozeně A jak vložit v reálném čase human-in-the-loop (HITL) kontroly pomocí interrupt() Chcete vidět kompletní demo v akci? . GitHub Repo Further Reading - Zabezpečení spolupráce AI prostřednictvím brány oprávnění Povolení MCP GitHub Repo LangChain MCP Adaptery Povolení ReBAC politiky LangGraph interrupt() Reference
