MCP Integration

from laddr import Agent, WorkerRunner
from laddr.llms import gemini
from laddr.core.mcp_tools import MCPToolProvider

# Create MCP tool provider
mcp_provider = MCPToolProvider(
    command="npx -y @modelcontextprotocol/server-filesystem /path/to/directory",
    transport="stdio"
)

# Create the Agent with MCP tools
agent = Agent(
    name="filesystem_agent",
    role="Filesystem Assistant",
    goal="Help users explore files and directories",
    backstory="A helpful assistant that can navigate and analyze files",
    llm=gemini(model="gemini-2.5-flash"),
    tools=[mcp_provider],  # MCP tools are automatically discovered and registered
)

# Run as worker
async def main():
    runner = WorkerRunner(agent=agent)
    await runner.start()

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

from laddr import Agent
from laddr.core.mcp_tools import MCPToolProvider

# Stdio transport (local command-based server)
mcp = MCPToolProvider(
    command="npx -y @modelcontextprotocol/server-filesystem /path",
    transport="stdio"
)

agent = Agent(
    name="researcher",
    role="Research Agent",
    goal="Research topics using MCP tools",
    tools=[mcp],  # MCP tools automatically available
    # ... other agent config
)

from laddr import Agent
from laddr.core.mcp_tools import MCPToolProvider, MultiMCPToolProvider

# Create multiple providers
filesystem_mcp = MCPToolProvider(
    command="npx -y @modelcontextprotocol/server-filesystem /path",
    transport="stdio",
    server_name="filesystem"
)

git_mcp = MCPToolProvider(
    command="uvx mcp-server-git",
    transport="stdio",
    server_name="git"
)

# Combine into multi-provider
multi_mcp = MultiMCPToolProvider([filesystem_mcp, git_mcp])

agent = Agent(
    name="developer",
    role="Developer Assistant",
    goal="Help with filesystem and git operations",
    tools=[multi_mcp],
    # ... other agent config
)

mcp = MCPToolProvider(
    command="npx -y @modelcontextprotocol/server-filesystem /path/to/dir",
    transport="stdio"
)

mcp = MCPToolProvider(
    url="https://docs.agno.com/mcp",
    transport="streamable-http",  # or "http"
    api_key="your-api-key"  # Optional
)

mcp = MCPToolProvider(
    url="https://mcp-server.example.com",
    transport="sse",
    api_key="your-api-key"  # Optional
)

mcp = MCPToolProvider(command="npx -y @modelcontextprotocol/server-filesystem /path")
agent = Agent(
    name="agent",
    tools=[mcp],
    # ... config
)
# Connection established automatically when agent first uses tools

mcp = MCPToolProvider(command="npx -y @modelcontextprotocol/server-filesystem /path")

# Connect explicitly
await mcp.connect()

try:
    agent = Agent(name="agent", tools=[mcp], ...)
    # Use agent...
finally:
    # Disconnect when done
    await mcp.disconnect()

async with MCPToolProvider(command="npx -y @modelcontextprotocol/server-filesystem /path") as mcp:
    agent = Agent(name="agent", tools=[mcp], ...)
    # Connection automatically closed when exiting context

mcp = MCPToolProvider(
    command="npx -y @modelcontextprotocol/server-filesystem /path",
    auto_refresh=True  # Reconnect and refresh tools on each run
)

# Server 1 provides: read_file
# Server 2 provides: read_file

# Result:
# - filesystem_read_file (from server_name="filesystem")
# - git_read_file (from server_name="git")

import asyncio
from laddr import Agent, WorkerRunner
from laddr.llms import gemini
from laddr.core.mcp_tools import MCPToolProvider

async def main():
    # Initialize MCP provider for filesystem
    mcp = MCPToolProvider(
        command="npx -y @modelcontextprotocol/server-filesystem /path/to/project",
        transport="stdio",
        server_name="filesystem"
    )
    
    # Create agent
    agent = Agent(
        name="filesystem_assistant",
        role="Filesystem Assistant",
        goal="Help users explore and analyze files and directories",
        backstory="""You are a helpful filesystem assistant. You can:
        - Navigate directories
        - Read and analyze files
        - Search for content
        - Provide file information""",
        llm=gemini(model="gemini-2.5-flash", temperature=0.3),
        tools=[mcp],
        instructions="""
        When helping users:
        1. Use filesystem tools to explore directories
        2. Read relevant files to answer questions
        3. Provide clear, organized information
        4. Be concise and focus on what the user asked
        """
    )
    
    # Run as worker
    runner = WorkerRunner(agent=agent)
    print("Starting filesystem assistant...")
    await runner.start()

if __name__ == "__main__":
    asyncio.run(main())

from laddr import Agent
from laddr.core.mcp_tools import MCPToolProvider, MultiMCPToolProvider

# Filesystem MCP
fs_mcp = MCPToolProvider(
    command="npx -y @modelcontextprotocol/server-filesystem .",
    transport="stdio",
    server_name="filesystem"
)

# Git MCP
git_mcp = MCPToolProvider(
    command="uvx mcp-server-git",
    transport="stdio",
    server_name="git"
)

# Combine
multi_mcp = MultiMCPToolProvider([fs_mcp, git_mcp])

agent = Agent(
    name="developer_assistant",
    role="Developer Assistant",
    goal="Help with codebase exploration and git operations",
    tools=[multi_mcp],
    # ... other config
)

try:
    # Use agent...
finally:
    await mcp.disconnect()

try:
    await mcp.connect()
except MCPError as e:
    logger.error(f"MCP connection failed: {e}")
    # Fallback behavior

MCPToolProvider(..., server_name="filesystem")  # Good
MCPToolProvider(...)  # Less clear with multiple servers

MCPToolProvider(url="https://...", auto_refresh=True)

mcp = MCPToolProvider(
    command="...",
    server_name="custom_name"  # Tools will be: custom_name_tool_name
)

if mcp.is_connected():
    tools = await mcp.discover_tools()
    print(f"Available tools: {[t['name'] for t in tools]}")

from laddr.core.tooling import register_mcp_tools

await register_mcp_tools(agent.tools, mcp_provider)