> ## Documentation Index
> Fetch the complete documentation index at: https://docs.streamnative.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Managed Agent Tools

> Learn how Orca Engine discovers agent tools, integrates Model Context Protocol servers, and keeps tool sets current at runtime.

Orca Engine aggregates every tool your agent can invoke and exposes them through `AgentContext`. Use the context API to request the latest tool list on each invocation:

```python theme={null}
from orca.functions.agent_context import AgentContext

available_tools = AgentContext.current().get_tools()
```

## Tool discovery overview

`AgentContext.current().get_tools()` returns an ordered list of tool definitions ready for use by your agent framework. The runtime combines two sources:

* **Static tools** that you register with your agent package or configure through deployment metadata.
* **Managed Model Context Protocol (MCP) tools** supplied by the StreamNative cloud console and connected MCP servers.

Tool entries with duplicate names are skipped automatically so the first matching definition wins. When your organization scopes tools through inclusion rules, only allowed entries appear in the final list.

## Use tools in agent code

Invoke `get_tools()` inside the handler that constructs your agent rather than caching results at import time. This ensures each invocation sees the current configuration and any MCP updates.

```python theme={null}
from agents import Agent, function_tool
from orca.functions.agent_context import AgentContext

@function_tool
async def fetch_weather(city: str) -> str:
    return "Weather data goes here"

managed_tools = AgentContext.current().get_tools()

root_agent = Agent(
    name="operations_assistant",
    instructions="Use managed tools whenever additional context is helpful.",
    tools=[fetch_weather, *managed_tools],
)
```

Agents built with other frameworks follow the same pattern: request the active context, append your static helpers, and pass the combined list to the runtime.

## Dynamic updates with the model context protocol

Orca Engine maintains long-lived Server-Sent Events (SSE) streams to each registered MCP server. These notifications power two capabilities:

* **Dynamic tool discovery**: When an MCP server adds, removes, or updates a tool, the runtime refreshes its catalog and the next call to `get_tools()` reflects the change—no redeployment required.
* **Real-time MCP messages**: SSE messages surface remote events so your agent can react to live signals, such as tool hot reloads or targeted prompts from connected systems.

When the runtime receives a "tools changed" notification and detects a difference from the cached definition set, it reloads the active agent instance before processing additional requests. This refresh ensures subsequent calls to `get_tools()` return the latest tools and that long-lived sessions see the updated capabilities.

Because MCP updates arrive asynchronously, call `get_tools()` within the request scope or immediately before you instantiate the agent. Avoid storing the returned list in module-level variables.

## Best practices

* Request `AgentContext.current().get_tools()` inside the invocation flow to pick up runtime changes.
* Use descriptive names and function comments for static tools so large-language-model-based agents can choose them accurately.
* Coordinate session strategy with your tooling approach—combine this page with [Agent Context](/agent-engine/agents-context) for state, metrics, and session controls.
* When testing locally, inject a mock context that provides representative tool lists before importing modules that expect runtime tools.

With these patterns, your Orca Engine agents can blend built-in helpers with dynamically managed MCP integrations while staying up to date automatically.