Agenty hostowane samodzielnie jako narzędzia MCP

Użyj agent-framework-hosting-mcp, aby udostępnić agenta lub przepływ pracy Agent Framework jako narzędzie w natywnym pakiecie SDK Model Context Protocol. Pakiet nie wybiera frameworka webowego ani nie obsługuje cyklu życia serwera MCP SDK; aplikacja nadal odpowiada za Server, rejestrację procedur obsługi, transport, zasady dotyczące klucza sesji, uwierzytelnianie, autoryzację i wdrożenie.

pip install --pre agent-framework-hosting-mcp

Konwertować na granicy protokołu

mcp_to_run(...) Konwertuje zweryfikowane argumenty narzędzia MCP na komunikaty platformy agentów i wybrane opcje czatu oraz mcp_from_run(...) konwertuje ukończoną odpowiedź na natywne wartości MCP ContentBlock . Użyj tych dwóch funkcji bezpośrednio, gdy kontrakt narzędzi aplikacji wymaga w pełni niestandardowego, natywnego schematu i procedury obsługi:

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    """Return the app-owned native MCP tool definition."""
    return [
        types.Tool(
            name="run_agent_manually",
            description=agent.description or "",
            inputSchema={
                "type": "object",
                "properties": {
                    TASK_ARGUMENT: {
                        "type": "string",
                        "description": "The request for the hosted agent.",
                    },
                    **CHAT_OPTION_ARGUMENTS,
                },
                "required": [TASK_ARGUMENT],
                "additionalProperties": False,
            },
        )
    ]


@server.call_tool()
async def call_tool(name: str, arguments: dict[str, object] | None) -> list[types.ContentBlock]:
    """Convert, run, and render without the agent-backed adapter."""
    if name != "run_agent_manually":
        raise ValueError(f"Unknown MCP tool: {name}")
    run = mcp_to_run(
        arguments,
        argument_name=TASK_ARGUMENT,
        chat_option_arguments=CHAT_OPTION_ARGUMENTS,
    )
    result = await agent.run(run["messages"], options=run["options"])
    return mcp_from_run(result)

Tylko nazwy argumentów wymienionych w pliku chat_option_arguments są kopiowane do run["options"]; inne argumenty MCP pozostają dostępne na nieprzetworzonej reprezentacji wiadomości, ale nie są przekazywane do klienta modelu.

Hostuj agenta jako pojedyncze wygenerowane narzędzie

AgentMCPTool wyprowadza natywną nazwę narzędzia, opis i schemat na podstawie agenta oraz zapewnia spójność listowania, parsowania, wykonywania i konwersji wyników, dzięki czemu oba nie mogą się rozjechać:

agent_tool = AgentMCPTool(
    agent,
    name="run_agent",
    argument_description="The request for the hosted agent.",
    chat_option_parameters={
        "reasoning_effort": {
            "type": "string",
            "enum": ["low", "medium", "high"],
            "description": "Optional reasoning effort for models that support it.",
        }
    },
)


@server.list_tools()
async def list_tools() -> list[types.Tool]:
    """Describe the app-owned MCP tool schema."""
    return await agent_tool.list_tools()


@server.call_tool()
async def call_tool(name: str, arguments: dict[str, object] | None) -> list[types.ContentBlock]:
    """Run the app-owned tool with native MCP and Agent Framework values."""
    return await agent_tool.call_tool(name, arguments)

AgentMCPTool używa nazwy i opisu agenta, chyba że zostanie zastąpiony. parameters Dodaje właściwości schematu JSON należące do aplikacji, które pozostają dostępne w nieprzetworzonych argumentach MCP, i chat_option_parameters dodaje właściwości, których wartości są jawnie kopiowane do opcji czatu programu Agent Framework.

Zachować sesję dla każdego wywołania

Przekaż istniejące AgentState i session_id_parameter, aby umożliwić powtarzanym wywołaniom z tym samym nieprzezroczystym identyfikatorem session_id zdefiniowanym przez aplikację kontynuowanie tej samej konwersacji:

session_locks: dict[str, asyncio.Lock] = {}


@server.list_tools()
async def list_tools() -> list[types.Tool]:
    """Return the agent-derived MCP tool definition."""
    return await agent_tool.list_tools()


@server.call_tool()
async def call_tool(name: str, arguments: dict[str, object] | None) -> list[types.ContentBlock]:
    """Serialize calls per app-owned session before using ``AgentState``."""
    session_id = arguments.get("session_id") if arguments else None
    if not isinstance(session_id, str) or not session_id:
        raise ValueError("MCP tool argument 'session_id' must be a non-empty string.")
    lock = session_locks.setdefault(session_id, asyncio.Lock())
    async with lock:
        return await agent_tool.call_tool(name, arguments)

AgentMCPTool Wykonuje AgentState tylko sekwencję pobierania/uruchamiania/ustawiania sesji; aplikacja musi uwierzytelniać lub autoryzować identyfikator sesji i serializować współbieżne wywołania dla tej samej sesji, co w przykładzie w przypadku sesji asyncio.Lock. To nie jest rozgałęzianie w stylu previous_response_id — aplikacja, która musi rozgałęzić konwersację, powinna przyjmować oddzielne identyfikatory źródłowy i docelowy, skopiować sesję źródłową i zapisać wynik pod kluczem docelowym.

Hostowanie przepływu pracy jako narzędzia

WorkflowMCPTool wyprowadza jedno natywne narzędzie MCP z typu wejściowego start-executora przepływu pracy i konwertuje dane wyjściowe ukończonego przepływu pracy. Dane wejściowe klasy danych, Pydantic i innych danych wejściowych w kształcie obiektu stają się argumentami MCP najwyższego poziomu; Pierwotne dane wejściowe są opakowane w konfigurowalną nazwę argumentu:

server = Server("agent-framework-hosting-mcp-workflow-sample")
workflow_tool = WorkflowMCPTool(
    WorkflowState(create_workflow, cache_target=False),
    name="draft_content",
)

Instancje przepływu pracy zachowują stan wykonania, więc aplikacje wymagające oddzielnych wywołań powinny udostępnić fabrykę WorkflowState z cache_target=False, jak pokazano powyżej. Przywracanie punktów kontrolnych, odpowiedzi z udziałem człowieka i identyfikatory kontynuacji pozostają po stronie aplikacji; jeśli przepływ pracy wymaga danych wejściowych z zewnątrz, adapter zgłasza wyjątek zamiast zwracać pusty, pomyślny wynik działania narzędzia.

Pełny zestaw uruchamialnych serwerów — w tym wariant FastMCP, który wyprowadza swój schemat z funkcji opatrzonej dekoratorem — znajdziesz w przykładach hostowania MCP.

Następne kroki

Głębiej:

• Omówienie samodzielnego hostingu
• Odpowiedzi openAI
• Telegram