Da KI-Agenten autonomer und fähiger werden, verschiebt sich ihre Rolle von passiven Assistenten zu proaktiven Akteuren.Die heutigen großen Sprachmodelle (LLMs) generieren nicht nur Text – sie führen Aufgaben aus, erhalten Zugriff auf APIs, modifizieren Datenbanken und steuern sogar die Infrastruktur. KI-Agenten ergreifen Aktionen, die einst ausschließlich für menschliche Benutzer reserviert waren, sei es beim Planen eines Meetings, beim Bereitstellen eines Dienstes oder beim Zugriff auf ein sensibles Dokument. , der Ein einzelnes halluziniertes Befehl, eine missverstandene Anweisung oder eine zu breite Berechtigung kann zu Datenleckungen, Compliance-Verstößen oder abgebrochenen Systemen führen. When agents operate without guardrails they can inadvertently make harmful or unauthorized decisions Deshalb wird die Integration Workflows sind für Agentensicherheit und Rechenschaftspflicht unerlässlich. human-in-the-loop (HITL) ist ein Rahmenwerk, mit dem KI-Agenten mit der Fähigkeit, empfindliche Handlungen, während erlaubt . Permit.io Zugriffsanforderung MCP request humans to remain the final decision-makers Permit.io Zugriffsanforderung MCP aufgebaut sind und integriert in beliebte Agent-Frameworks wie und Dieses System ermöglicht es Ihnen, Genehmigungsworkflows direkt in Ihre LLM-gestützten Anwendungen einzufügen. Erlaubnis.de LangChain LangGraph In diesem Tutorial lernen Sie: Warum die Übertragung sensibler Berechtigungen auf Menschen für eine vertrauenswürdige KI entscheidend ist Wie das Modellkontextprotokoll (MCP) von Permit.io Zugriffsanfrage-Workflows ermöglicht, Wie man ein reales System baut, das LLM-Intelligenz mit menschlicher Überwachung verbindet – mit LangGraphs Interrupt()-Funktion. Bevor wir in unsere Demo-Anwendung und Implementierungsschritte eintauchen, lassen Sie uns kurz über die Bedeutung der Übertragung von KI-Berechtigungen an Menschen sprechen. Warum die Übertragung von KI-Berechtigungen an Menschen entscheidend ist KI-Agenten sind mächtig, aber wie wir alle wissen, sind sie nicht unfehlbar. Sie erzeugen Antworten, aber sie können die Konsequenzen nicht beurteilen.Und wenn diese Agenten in reale Systeme integriert sind – Bank-Tools, interne Dashboards, Infrastrukturkontrollen – das ist eine gefährliche Lücke. In diesem Zusammenhang ist alles, was falsch gehen kann, ziemlich klar: Übermäßige Agenten: LLMs können Zugang zu Werkzeugen erhalten, die sie nicht berühren sollten, entweder durch Design oder durch Zufall. Halluzinierte Tool-Anrufe: Agenten können Befehle, Argumente oder IDs herstellen, die nie existiert haben. Mangel an Auditbarkeit: Ohne menschliche Checkpoints gibt es keine klare Aufzeichnung darüber, wer was oder warum genehmigt hat. Delegation is the solution. Anstatt Agenten unkontrollierte Macht zu geben, geben wir ihnen ein Protokoll: „Man kann fragen, aber ein Mensch entscheidet.“ Durch Einführung Mit der Genehmigung an Schlüsselentscheidungspunkten erhalten Sie: human-in-the-loop (HITL) Sicherheit: Verhindern Sie irreversible Aktionen, bevor sie auftreten. Rechenschaftspflicht: Erfordert explizite menschliche Abmeldung für hohe Einsätze. Kontrolle: Lassen Sie die Leute die Regeln festlegen – wer kann genehmigen, was kann genehmigt werden und wann. Es ist der Unterschied zwischen einem Agent Etwas und ein Agent etwas zu tun. tun Verlangen Und es ist genau das, was Zugriffsanforderung MCP ermöglicht. Erlaubnis.de Permit.io Zugriffsanforderung MCP ist ein Kernteil der Model Context Protocol (MCP) – eine Spezifikation, die KI-Agenten einen sicheren, politisch bewussten Zugang zu Tools und Ressourcen bietet. The Access Request MCP Erlaubnis.de Betrachten Sie es als eine Brücke zwischen und . LLMs that want to act humans who need control Was es tut Mit Permit's Access Request MCP können KI-Agenten: Zugriff auf eingeschränkte Ressourcen anfordern (z. B. „Kann ich auf dieses Restaurant zugreifen?“) Genehmigung anfordern, um sensible Vorgänge durchzuführen (z. B. „Kann ich dieses eingeschränkte Gericht bestellen?“) Warten Sie auf den menschlichen Eingang, bevor Sie fortfahren – über den interrupt() Mechanismus von LangGraph Loggen Sie den Antrag und die Entscheidung für die Prüfung und Compliance Hinter den Kulissen benutzt er ’s Autorisierungskapazitäten, die für die Unterstützung von: Erlaubnis.de ReBAC (Relationship-Based Access Control) und andere Fine-grained Authorization (FGA) Richtlinien. Arbeitsabläufe genehmigen Politikunterstützte Elemente, die über UI, API und LLM-Kontexte hinweg funktionieren ReBAC Fine-grained Authorization (FGA) ist eine Arbeitsabläufe genehmigen Politisch unterstützte Elemente Plug-and-Play mit LangChain und LangGraph Permit's MCP ist direkt in die und Das Ökosystem: LangChain MCP Adapter LangGraph Sie können Permit Elements als LangGraph-kompatible Tools aussetzen. Sie können den Agent mit interrupt() unterbrechen, wenn sensible Aktionen auftreten. Sie können die Ausführung auf der Grundlage von echten menschlichen Entscheidungen wieder aufnehmen. Es ist der einfachste Weg, um Kein custom backend nötig. inject human judgment into AI behavior Wenn wir die Implementierung und ihre Vorteile verstehen, kommen wir in unsere Demo-Anwendung. Was wir bauen werden - Demo Application Overview In diesem Tutorial werden wir ein In dem ein Die sie. real-time approval workflow AI agent can request access or perform sensitive actions, but only a human can approve Szenario: Familiengüterbestellsystem Um zu sehen, wie der MCP von Permit dazu beitragen kann, einen HITL-Workflow in einer Benutzeranwendung zu aktivieren, modellieren wir Für eine Familie: food ordering system Eltern können alle Restaurants und Gerichte zugreifen und verwalten. Kinder können öffentliche Gegenstände anzeigen, müssen aber Zugang zu eingeschränkten Restaurants oder teuren Gerichten anfordern. Wenn ein Kind einen Antrag stellt, erhält ein Elternteil ihn zur Überprüfung und muss ihn ausdrücklich genehmigen oder ablehnen, bevor die Maßnahme fortgesetzt wird. Dieser Einsatzfall spiegelt ein gemeinsames Muster wider: „Agenten können helfen, aber Menschen entscheiden.“ Tech Stack We’ll build this HITL-enabled agent using: Permit.io - Bearbeitet Genehmigungen, Rollen, Richtlinien und Genehmigungen MCP-Server erlauben – Arbeitsabläufe als Werkzeuge erlauben, die der Agent verwenden kann LangChain MCP-Adapter - Brücken ermöglichen MCP-Tools in LangGraph & LangChain LangGraph - Orchestert den Workflow des Agenten mit Interrupt() Support Gemini 2.0 Flash - Leichtes, multimodales LLM, das als Argumentationsmotor des Agenten verwendet wird Python - Der Klebstoff, der alles zusammenhält Sie werden mit einem funktionierenden System enden, in dem Agenten mit Menschen zusammenarbeiten können, um sicheres, absichtliches Verhalten zu gewährleisten - mit echten Richtlinien, echten Tools und Echtzeitgenehmigungen. A repository with the full code for this application is available here. Ein Repository mit dem vollständigen Code für diese Anwendung ist hier verfügbar. Schritt für Schritt Tutorial In diesem Abschnitt gehen wir durch, wie wir ein voll funktionsfähiges Human-in-the-loop-Agentsystem mit und Langgraph. Erlaubnis.de Wir werden abdecken: Modellierung mit Genehmigung Erlaubnis für den MCP Server Erstellen eines LangGraph + LangChain MCP-Clients Hinzufügen von Human-in-the-Loop mit interrupt() Führen Sie den vollständigen Workflow Lassen Sie uns in sie ein- Modellierung mit Genehmigung Wir werden anfangen, indem wir die Zugriffsregeln Ihres Systems innerhalb des Dadurch können Sie modellieren, welche Benutzer was tun können und welche Aktionen einen Genehmigungsfluss auslösen sollten. Erlauben.io Dashboard Create a ReBAC Resource Navigieren Sie zum Seite aus der Sidebar, dann: Policy Klicken Sie auf das Tab Ressourcen Klicken Sie auf Erstellen einer Ressource Name der Ressource: Restaurants Under , define two roles: ReBAC Options parent child-can-order Klicken Sie auf Save Gehen Sie jetzt zu den Tab und Zuweisung von Berechtigungen: Policy Editor Elternteil: Vollzugriff (Erstellen, Lesen, Aktualisieren, Löschen) Kindergarten: Lesen Set Up Permit Elements Gehen Sie zu den Tab von der Seitenleiste. in der Abschnitt, Klick . 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 Klicken Sie auf Erstellen Klicken Sie auf die neu erstellte Elementkarte „Code erhalten“ und nehmen Sie die Konfigurations-ID: restaurant-requests zur Kenntnis. Add Operation Approval Elements Create a new element: Operation Approval : Dish Approval Name : restaurants Resource Type Klicken Sie auf Erstellen Then create an element: Approval Management : Dish Requests Name Klicken Sie auf Get Code und kopieren Sie die config ID: dish-requests. Add Test Users & Resource Instances Navigieren Sie zu Directory > Instances Click Add Instance : restaurants Resource Type : Instance Key pizza-palace : Default Tenant (or your working tenant) Tenant Wechseln Sie zum User Tab 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 Sobald Permit konfiguriert ist, sind wir bereit, den MCP-Server zu klonen und Ihre Richtlinien mit einem arbeitenden Agent zu verbinden. Erlaubnis für den MCP Server Mit Ihren Richtlinien im Permit-Dashboard modelliert, ist es an der Zeit, sie zum Leben zu erwecken, indem Sie die Ein lokaler Service, der Ihre Zugriffsanfragen und Genehmigungsströme als Werkzeuge darstellt, die ein KI-Agent verwenden kann. Permit MCP server Clone and Install the MCP Server Beginnen Sie damit, indem Sie das MCP-Server-Repository klonen und eine virtuelle Umgebung einrichten. 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 Erstellen a Datei an der Wurzel des Projekts auf der Grundlage der vorgesehenen , und füllen Sie es mit den richtigen Werten aus Ihrer Permit-Einstellung: .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= Sie können diese Werte mithilfe der folgenden Ressourcen abrufen: Ort_PDP_URL Permit_API Schlüssel Projekt - ID ENV_ID ☀️ Hinweis: Wir verwenden für dieses Tutorial zur Unterstützung von ReBAC-Bewertung und Low-Latency, Offline-Tests. Die lokale PDP (Policy Decision Point) Start the Server Mit allem vor Ort können Sie nun den MCP-Server lokal ausführen: uv run -m src.permit_mcp Sobald der Server ausgeführt ist, wird er Ihre konfigurierten Erlaubniselemente (Zugriffsanfrage, Genehmigungsmanagement usw.) als Tools, die der Agent über das MCP-Protokoll anrufen kann, freigeben. Erstellen eines LangGraph + LangChain MCP-Clients Nachdem der Permit MCP-Server in Betrieb ist, werden wir einen AI-Agent-Client erstellen, der mit ihm interagieren kann. Verwenden Sie einen von Gemini angetriebenen LLM, um zu entscheiden, welche Aktionen zu ergreifen sindDynamisch MCP-Tools wie request_access, approve_operation_approval usw. anrufen. Vollständig innerhalb eines LangGraph-Workflows laufen Pause für menschliche Überprüfung mit interrupt() (im nächsten Abschnitt) Lassen Sie uns die Dots verbinden. Install Required Dependencies In Ihrem MCP-Projektverzeichnis installieren Sie die notwendigen Pakete: uv add langchain-mcp-adapters langgraph langchain-google-genai Das gibt Ihnen: langchain-mcp-Adapter: Konvertiert Permit MCP-Tools automatisch in LangGraph-kompatible Tools langgraph: Für die Orchestrierung grafbasierter Workflows langchain-google-genai: Für die Interaktion mit Gemini 2.0 Flash Add Google API Key Sie benötigen einen API-Schlüssel von Gemini zu benutzen. Google hat ein Studio Fügen Sie den Schlüssel zu Ihrem Die Datei: .env GOOGLE_API_KEY=your-key-here Build the MCP Client Erstellen einer Datei namens In Ihrem Projekt Root. client.py Wir werden diese Datei in logische Blöcke aufteilen: 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"], ) Definieren Sie den Shared Agent State: 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) Im obigen Code haben wir einen LLM-Node und seinen bedingten Rand definiert, der auf die Wir haben auch eine Funktion definiert, um das Diagramm mit einem in-Memory-Checkpointer einzurichten und zu kompilieren. run_tool Fügen Sie anschließend die folgende Zeile des Codes hinzu, um die Antwort aus dem Diagramm zu streamen, und fügen Sie eine interaktive Chat-Schleife hinzu, die läuft, bis sie explizit abgeschaltet ist. 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 Sobald Sie alles gespeichert haben, starten Sie den Client: uv run client.py Nach dem Ausführen wird eine neue Bilddatei namens Es wird erschaffen, was die Grafik zeigt. workflow_graph.png Mit allem, was eingerichtet ist, können wir nun Abfragen wie diese angeben: 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! Adding Human-in-the-Loop with interrupt() Mit Ihrem LangGraph-gestützten MCP-Client, der ausgeführt wird, können jetzt Permit-Tools automatisch angerufen werden. Wie zum Beispiel den Zugang zu einer eingeschränkten Ressource gewähren oder eine hochrisikoreiche Operation genehmigen? sensitive, Das ist, wo Langgraph’s Es wird nützlich. interrupt() Jetzt fügen wir ein Abfangen und Pausen des Workflows, wenn der Agent versucht, kritische Tools wie: human approval node Zustimmung_Zugriff_Anfrage Akzeptanz - Akzeptanz - Akzeptanz Ein Mensch wird gebeten, Das Tool ruft, bevor der Agent voranschreitet. manually approve or deny Define the Human Review Node Auf der Spitze deines Datei (vorher ), fügen Sie die folgende Funktion hinzu: 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"], }]}) Dieser Knoten prüft, ob das Gerät, das angerufen wird, als „hohes Risiko“ angesehen wird. Update Graph Routing Ändern Sie die funktioniert so, dass das Tool den Weg zum menschlichen Überprüfungsknoten anruft, anstatt sofort ausgeführt zu werden: 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 Aktualisieren Sie die Funktion zum Hinzufügen der Wie ein Knoten im Graph: 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 Lassen Sie uns schließlich Ihre Funktion, um zu erkennen, wenn das Diagramm unterbrochen wird, eine Entscheidung zu fordern und mit menschlichem Eingang fortzusetzen . stream_responses Command(resume={"action": user_input}) Nach dem Ausführen des Clients sollte das Diagramm nicht so aussehen: Nach dem Ausführen des Clients, Ihr Diagramm ( ) wird nun einen menschlichen Überprüfungsknoten zwischen dem LLM und den Werkzeugausführungsphasen enthalten: workflow_graph.png Dies gewährleistet, dass Jedes Mal, wenn der Agent versucht, eine Entscheidung zu treffen, die Berechtigungen ändern oder Einschränkungen umgehen könnte. you remain in control Mit diesem haben Sie Ihrem KI-Agent erfolgreich menschliche Überwachung hinzugefügt, ohne Ihre Tools oder Backend-Logik neu zu schreiben. Schlussfolgerung In diesem Tutorial haben wir einen sicheren, menschlich bewussten KI-Agenten mit . Permit.io Zugriffsanforderung MCP , der Langgrafen und LangChain MCP Adapter Permit.io Zugriffsanforderung MCP Langgrafen LangChain MCP Adapter Anstatt den Agent unkontrolliert zu lassen, gaben wir ihm die Macht, Zugang und Genauso wie ein verantwortungsvolles Teammitglied es tun würde. request defer critical decisions to human users, We covered: Modellieren von Berechtigungen und Genehmigungsströmen mithilfe von Permit Elements und ReBAC Wie man diese Flüsse über den Permit MCP-Server exponiert So erstellen Sie einen LangGraph-basierten Client, der diese Tools auf natürliche Weise anruft Und wie man Echtzeit-Human-in-the-loop (HITL) -Checks mit interrupt() einfügt Möchten Sie die vollständige Demo in Aktion sehen? . GitHub Repo Further Reading - Sichere AI-Kollaboration über ein Permissions Gateway MCP GitHub Repo erlauben LangChain MCP Adapter ReBAC-Politik erlauben LangGraph interrupt() Referenz
