Chuyển nhượng quyền AI cho người dùng con người với Permit.io's Access Request MCP

Khi các đại lý AI trở nên tự trị và có khả năng hơn, vai trò của họ đang chuyển từ trợ lý thụ động sang các diễn viên chủ động.Mô hình ngôn ngữ lớn (LLM) ngày nay không chỉ tạo văn bản - họ thực hiện các nhiệm vụ, truy cập API, sửa đổi cơ sở dữ liệu và thậm chí kiểm soát cơ sở hạ tầng.

Các nhân viên AI đang thực hiện các hành động mà trước đây chỉ dành riêng cho người dùng con người, cho dù đó là sắp xếp một cuộc họp, triển khai một dịch vụ hoặc truy cập vào một tài liệu nhạy cảm.

When agents operate without guardrails,they can inadvertently make harmful or unauthorized decisionsMột lệnh ảo giác duy nhất, lời nhắc bị hiểu lầm hoặc quyền quá rộng có thể dẫn đến rò rỉ dữ liệu, vi phạm tuân thủ hoặc hệ thống bị hỏng.

Đó là lý do tại sao hội nhậphuman-in-the-loop (HITL)dòng công việc là điều cần thiết cho sự an toàn và trách nhiệm của đại lý.

Yêu cầu truy cập Permit.io MCPlà một khuôn khổ được thiết kế để cho phép các đại lý AI có khả năngrequestcác hành động nhạy cảm, trong khi cho phéphumans to remain the final decision-makers.

xây dựngCho phép.io and integrated into popular agent frameworks like LangChainvàLangGraph, hệ thống này cho phép bạn chèn dòng công việc phê duyệt trực tiếp vào các ứng dụng được cung cấp bởi LLM của bạn.

Trong hướng dẫn này, bạn sẽ học:

• Tại sao chuyển giao quyền nhạy cảm cho con người là rất quan trọng đối với AI đáng tin cậy,
• Làm thế nào Permit.io Model Context Protocol (MCP) cho phép dòng công việc truy cập yêu cầu,
• How to build a real-world system that blends LLM intelligence with human oversight—using LangGraph’s interrupt() feature.

Trước khi chúng ta đi sâu vào các bước ứng dụng demo và thực hiện của chúng tôi, chúng ta hãy thảo luận ngắn gọn về tầm quan trọng của việc giao quyền AI cho con người.

Tại sao ủy quyền AI cho con người là rất quan trọng

Các đại lý AI rất mạnh mẽ, nhưng, như tất cả chúng ta đều biết, họ không phải là không thể sai lầm.

Họ làm theo các hướng dẫn, nhưng họ không hiểu bối cảnh như con người làm.Họ tạo ra phản ứng, nhưng họ không thể đánh giá hậu quả.Và khi các đại lý được tích hợp vào các hệ thống thực tế - công cụ ngân hàng, bảng điều khiển nội bộ, điều khiển cơ sở hạ tầng - đó là một khoảng cách nguy hiểm.

Trong bối cảnh này, tất cả những gì có thể đi sai là khá rõ ràng:

• Các đại lý quá cho phép: LLM có thể được cấp quyền truy cập vào các công cụ mà họ không nên chạm vào, hoặc do thiết kế hoặc vô tình.
• Các cuộc gọi công cụ ảo giác: Các đại lý có thể tạo ra các lệnh, đối số hoặc ID không bao giờ tồn tại.
• Thiếu khả năng kiểm toán: Nếu không có các điểm kiểm tra của con người, không có hồ sơ rõ ràng về việc ai đã phê duyệt cái gì, hoặc tại sao.

Delegation is the solution.

Thay vì cho các đại lý quyền lực không kiểm soát, chúng tôi cung cấp cho họ một giao thức:“Bạn có thể hỏi, nhưng con người quyết định.”

bằng cách giới thiệuhuman-in-the-loop (HITL)phê duyệt tại các điểm quyết định chính, bạn nhận được:

• An toàn: Ngăn chặn các hành động không thể đảo ngược trước khi chúng xảy ra.
• Trách nhiệm: Yêu cầu đăng ký con người rõ ràng cho các hoạt động có lãi suất cao.
• Kiểm soát: Hãy để mọi người thiết lập các quy tắc – ai có thể phê duyệt, những gì có thể được phê duyệt và khi nào.

Đó là sự khác biệt giữa một đại lýlàmMột cái gì đó và một nhân viênYêu cầuđể làm điều gì đó.

Và đó chính xác là những gìCho phép.ioYêu cầu truy cập MCP cho phép

Yêu cầu truy cập Permit.io MCP

The Access Request MCPLà một phần cốt lõi củaCho phép.ioModel Context Protocol (MCP) – một thông số kỹ thuật cung cấp cho các đại lý AI quyền truy cập an toàn, có ý thức về chính sách vào các công cụ và tài nguyên.

Hãy nghĩ về nó như một cây cầu giữaLLMs that want to actvàhumans who need control.

What it does

Permit’s Access Request MCP enables AI agents to:

• Yêu cầu truy cập vào các tài nguyên bị hạn chế (ví dụ: "Tôi có thể truy cập nhà hàng này không?")
• Yêu cầu phê duyệt để thực hiện các hoạt động nhạy cảm (ví dụ: "Tôi có thể đặt hàng món ăn bị hạn chế này không?")
• Chờ đợi đầu vào của con người trước khi tiến hành—thông qua cơ chế interrupt() của LangGraph
• Đăng ký yêu cầu và quyết định kiểm toán và tuân thủ

Phía sau sân khấu, nó sử dụngCho phép.io‘s khả năng ủy quyền được xây dựng để hỗ trợ:

• Chính sách kiểm soát truy cập dựa trên mối quan hệ (Relationship-Based Access Control) và chính sách cấp phép hạt mịn (Fine-grained Authorization, FGA) khác.
• phê duyệt workflow
• Các yếu tố được hỗ trợ bởi chính sách hoạt động trên các ngữ cảnh UI, API và LLM

Plug-and-play với LangChain và LangGraph

MCP của Permit được tích hợp trực tiếp vàoLangChain MCP Adapter and LangGraphHệ sinh thái :

• Bạn có thể cho phép Elements làm công cụ tương thích với LangGraph.
• Bạn có thể tạm dừng tác nhân bằng cách tạm dừng() khi các hành động nhạy cảm xảy ra.
• You can resume execution based on real human decisions.

Đó là cách dễ nhất đểinject human judgment into AI behaviorKhông cần custom backend

Hiểu được việc thực hiện và lợi ích của nó, hãy vào ứng dụng demo của chúng tôi.

Những gì chúng tôi sẽ xây dựng - Demo Application Overview

Trong hướng dẫn này, chúng tôi sẽ xây dựng mộtreal-time approval workflowTrong đó mộtAI agent can request access or perform sensitive actions, but only a human can approveHọ

Lời bài hát: Family Food Order System

Để xem MCP của Permit có thể giúp kích hoạt một dòng công việc HITL trong một ứng dụng người dùng như thế nào, chúng tôi sẽ mô hình mộtfood ordering system for a family:

• Cha mẹ có thể truy cập và quản lý tất cả các nhà hàng và các món ăn.
• Trẻ em có thể xem các mặt hàng công cộng, nhưng phải yêu cầu truy cập vào các nhà hàng bị hạn chế hoặc các món ăn đắt tiền.
• Khi một đứa trẻ nộp một yêu cầu, cha mẹ nhận được nó để xem xét và phải rõ ràng chấp thuận hoặc từ chối nó trước khi hành động được tiến hành.

Trường hợp sử dụng này phản ánh một mô hình chung:“Các đại lý có thể giúp đỡ, nhưng con người quyết định.”

Công nghệ Stack

Chúng tôi sẽ xây dựng HITL-enabled agent này bằng cách sử dụng:

• Permit.io - Xử lý ủy quyền, vai trò, chính sách và phê duyệt
• Cho phép MCP Server - Hiển thị Cho phép dòng công việc như các công cụ mà đại lý có thể sử dụng
• LangChain MCP Adapters - Cầu nối các công cụ MCP của LangChain vào LangGraph & LangChain
• LangGraph - Chuẩn bị dòng công việc của đại lý với hỗ trợ interrupt()
• Gemini 2.0 Flash - LLM đa phương tiện nhẹ được sử dụng làm công cụ lý luận của đại lý
• Python – The glue holding it all together (tạm dịch: Kính dán giữ tất cả mọi thứ lại với nhau)

Bạn sẽ kết thúc với một hệ thống làm việc nơi các đại lý có thể cộng tác với con người để đảm bảo hành vi an toàn, có chủ ý - sử dụng các chính sách thực tế, các công cụ thực tế và phê duyệt thời gian thực.

A repository with the full code for this application is available here.

Hướng dẫn Step-by-Step

Trong phần này, chúng tôi sẽ đi bộ qua làm thế nào để thực hiện một hệ thống đại lý con người đầy đủ chức năng bằng cách sử dụngCho phép.iovà Langgraph.

Chúng tôi sẽ bao gồm:

• Mô hình giấy phép với giấy phép
• Cài đặt Permit MCP Server
• Tạo một LangGraph + LangChain MCP Client
• Thêm Human-in-the-Loop với interrupt()
• Chạy toàn bộ dòng công việc

Chúng ta hãy vào đó -

Mô hình giấy phép với giấy phép

Chúng tôi sẽ bắt đầu bằng cách xác định các quy tắc truy cập của hệ thống của bạn bên trongLời bài hát: DashboardĐiều này cho phép bạn mô hình người dùng có thể làm gì và hành động nào nên kích hoạt một luồng phê duyệt.

Create a ReBAC Resource

Navigate đến thePolicyTrang từ sidebar, sau đó:

• Click vào Resources tab
• Click vào Create a Resource
• Tên tài nguyên: Nhà hàng
• Under ReBAC Options, define two roles:
  • parent
  • child-can-order
• Click vào Save

Bây giờ, hãy đi đếnPolicy EditorTab và gán quyền:

• parent: full access (tạo, đọc, cập nhật, xóa)
• Lời bài hát: Read

Set Up Permit Elements

Đi đến theElementstab từ sidebar.In theUser ManagementTrang chủ, ClickCreate Element.

• Configure the element as follows:
  • Name: Restaurant Requests
  • Configure elements based on: ReBAC Resource Roles
  • Resource Type: restaurants
  • Role permission levels
    • Level 1 – Workspace Owner: parent
    • Assignable Roles: child-can-order
• Click tạo
• Trên thẻ yếu tố mới được tạo, nhấp vào Get Code và lưu ý đến config ID: restaurant-requests.

Add Operation Approval Elements

• Create a new Operation Approval element:
  • Name: Dish Approval
  • Resource Type: restaurants
• Click tạo

• Then create an Approval Management element:
  • Name: Dish Requests
• Nhấp vào Get Code và sao chép config ID: dish-requests.

Add Test Users & Resource Instances

• Navigate to Directory > Địa chỉ
• Click Add Instance
  • Resource Type: restaurants
  • Instance Key: pizza-palace
  • Tenant: Default Tenant (or your working tenant)

• Chuyển sang 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

Một khi Permit được cấu hình, chúng tôi đã sẵn sàng để nhân bản máy chủ MCP và kết nối chính sách của bạn với một đại lý làm việc.

Cài đặt Permit MCP Server

Với các chính sách của bạn được mô hình trong bảng điều khiển Cho phép, đã đến lúc đưa chúng vào cuộc sống bằng cách thiết lậpPermit MCP serverMột dịch vụ địa phương phơi bày yêu cầu truy cập và dòng phê duyệt của bạn như các công cụ mà một đại lý AI có thể sử dụng.

Clone and Install the MCP Server

Bắt đầu bằng cách nhân bản kho máy chủ MCP và thiết lập môi trường ảo.

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

Tạo a.envfile at the root of the project based on the provided.env.example, và điền nó với các giá trị chính xác từ thiết lập Permit của bạn:

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=

Bạn có thể lấy các giá trị này bằng cách sử dụng các tài nguyên sau:

• Địa chỉ_PDP_URL
• Cho phép_API_KEY
• Dự án_ID
• TN_ID

⚠️ Note: We are using Local PDP (Politics Decision Point) (Địa điểm quyết định chính sách)cho hướng dẫn này để hỗ trợ đánh giá ReBAC và thử nghiệm chậm trễ thấp, ngoại tuyến.

Start the Server

Với tất cả mọi thứ ở vị trí, bây giờ bạn có thể chạy máy chủ MCP tại địa phương:

uv run -m src.permit_mcp

Một khi máy chủ đang chạy, nó sẽ phơi bày các yếu tố cho phép được cấu hình của bạn (yêu cầu truy cập, quản lý phê duyệt, v.v.) như các công cụ mà đại lý có thể gọi thông qua giao thức MCP.

Tạo một LangGraph + LangChain MCP Client

Bây giờ rằng máy chủ Permit MCP đang chạy, chúng tôi sẽ xây dựng một máy khách đại lý AI có thể tương tác với nó.

• Sử dụng một Gemini-powered LLM để quyết định hành động nào để thực hiệnDynamically invoke MCP tools like request_access, approve_operation_approval, v.v.
• Chạy hoàn toàn trong một dòng công việc LangGraph
• Pause for human review using interrupt() (trong phần tiếp theo)

Hãy kết nối các dots.

Install Required Dependencies

Bên trong thư mục dự án MCP của bạn, cài đặt các gói cần thiết:

uv add langchain-mcp-adapters langgraph langchain-google-genai

Điều này cho bạn:

• langchain-mcp-adapters: Tự động chuyển đổi Permit MCP tools thành công cụ tương thích với LangGraph
• langgraph: Để tổ chức các dòng công việc dựa trên đồ thị
• langchain-google-genai: Đối với tương tác với Gemini 2.0 Flash

Add Google API Key

Bạn sẽ cần một phím API từTrang chủ Google AI StudioSử dụng Gemini

Thêm chìa khóa vào của bạn.envFile :

GOOGLE_API_KEY=your-key-here

Build the MCP Client

Tạo file có tênclient.pytrong dự án root của bạn.

Chúng ta sẽ chia tệp này xuống thành các khối logic:

• 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')
)

• Configure MCP Server ParametersTell LangGraph how to communicate with the running MCP server:

  server_params = StdioServerParameters( command="python", args=["src/permit_mcp/server.py"], )
  

Xác định trạng thái đại lý chia sẻ:

class State(TypedDict):
    messages: Annotated[list, add_messages]

• Define Workflow Nodes and the 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)
  

Trong mã trên, chúng tôi đã xác định một nút LLM và cạnh có điều kiện của nó, đường dẫn đếnrun_toolNode nếu có một cuộc gọi công cụ trong thông điệp trạng thái, hoặc kết thúc biểu đồ.Chúng tôi cũng đã xác định một hàm để thiết lập và biên dịch biểu đồ với một dấu kiểm trong bộ nhớ.

Tiếp theo, thêm dòng mã sau để truyền phản hồi từ biểu đồ và thêm một vòng tròn trò chuyện tương tác, sẽ chạy cho đến khi nó được thoát rõ ràng.

• Stream Output and Handle Chat Input, and an 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

Một khi bạn đã lưu tất cả mọi thứ, hãy bắt đầu khách hàng:

uv run client.py

Sau khi chạy, một tệp hình ảnh mới được gọi làworkflow_graph.pngsẽ được tạo ra, mà biểu đồ cho thấy.

Với mọi thứ được thiết lập, bây giờ chúng ta có thể xác định các truy vấn như thế này:

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!

Thêm Human-in-the-Loop vớiinterrupt()

Với máy khách MCP chạy bằng LangGraph của bạn, các công cụ Permit giờ đây có thể được gọi tự động.sensitive,như cấp quyền truy cập vào một tài nguyên hạn chế hoặc phê duyệt một hoạt động rủi ro cao?

Đó là nơi mà LangGraphinterrupt()trở nên hữu ích.

Bây giờ chúng ta sẽ thêm ahuman approval nodeđể chặn và tạm dừng dòng công việc bất cứ khi nào đại lý cố gắng kêu gọi các công cụ quan trọng như:

• Chấp nhận_Access_Request
• Chấp nhận_Operation_Approval

Một con người sẽ được yêu cầumanually approve or denycông cụ gọi trước khi đại lý tiến hành.

Define the Human Review Node

Trên đỉnh của bạnclient.pyFile (Trước khisetup_graph+ Thêm chức năng sau:

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"],
    }]})

Node này kiểm tra xem công cụ được gọi có được coi là "rủi ro cao" hay không.Nếu có, biểu đồ bị gián đoạn với một lời nhắc yêu cầu xác nhận của con người.

Update Graph Routing

Thay đổi theroute_after_llmchức năng để công cụ gọi đường dẫn đến nút đánh giá của con người thay vì chạy ngay lập tức:

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

Cập nhật Thesetup_graphchức năng để thêmhuman_review_node as a node in the graph:

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

Cuối cùng, hãy nâng caostream_responseschức năng để phát hiện khi biểu đồ bị gián đoạn, nhắc cho một quyết định, và tiếp tục với đầu vào của con người bằng cách sử dụngCommand(resume={"action": user_input}).

Sau khi chạy máy khách, biểu đồ không nên trông như thế này:

Sau khi chạy máy khách, biểu đồ của bạn (workflow_graph.png) bây giờ sẽ bao gồm một nút đánh giá của con người giữa các giai đoạn thực hiện LLM và công cụ:

Điều này đảm bảo rằngyou remain in controlBất cứ khi nào đại lý cố gắng đưa ra quyết định có thể thay đổi quyền hoặc bỏ qua các hạn chế.

Với điều này, bạn đã thành công thêm sự giám sát của con người vào đại lý AI của bạn, mà không phải viết lại các công cụ hoặc logic backend của bạn.

Kết luận

Trong hướng dẫn này, chúng tôi đã xây dựng một đại lý AI an toàn, nhận thức của con người bằng cách sử dụngYêu cầu truy cập Permit.io MCP,LangGraphvàBộ chuyển đổi LangChain MCP.

Thay vì để cho đại lý hoạt động không kiểm soát, chúng tôi đã cho nó sức mạnh đểrequestTruy cập vàdefer critical decisions to human users,Giống như một thành viên có trách nhiệm sẽ làm.

We covered:

• Cách mô hình quyền và dòng phê duyệt bằng cách sử dụng Permit Elements và ReBAC
• Làm thế nào để phơi bày các luồng thông qua Permit MCP server
• Làm thế nào để xây dựng một khách hàng LangGraph-powered mà gọi các công cụ này một cách tự nhiên
• Và làm thế nào để chèn thời gian thực người trong vòng (HITL) kiểm tra bằng cách sử dụng interrupt()

Muốn xem toàn bộ demo trong hành động?GitHub Repo.

Further Reading -

• Bảo mật AI Collaboration Through a Permissions Gateway
• Cho phép MCP GitHub Repo
• Bộ điều hợp LangChain MCP Adapter
• Cho phép chính sách ReBAC
• LangGraph interrupt() tham chiếu