Framework integrations

import os
from openai import OpenAI

client = OpenAI()
response = client.responses.create(
    model=os.environ["OPENAI_MODEL"],
    input="Research the requested topic and cite the sources you use.",
    tools=[{
        "type": "mcp",
        "server_label": "locus_pro",
        "server_url": os.environ["LOCUS_MCP_URL"],
        "authorization": os.environ["LOCUS_AGENT_CONNECTION"],
        "require_approval": "never",
    }],
)

print(response.output_text)

import os
from agents import Agent, HostedMCPTool

agent = Agent(
    name="Locus research agent",
    instructions="Use only the approved Locus tools.",
    tools=[
        HostedMCPTool(tool_config={
            "type": "mcp",
            "server_label": "locus_pro",
            "server_url": os.environ["LOCUS_MCP_URL"],
            "authorization": os.environ["LOCUS_AGENT_CONNECTION"],
            "require_approval": "never",
        })
    ],
)

import os
import anthropic

client = anthropic.Anthropic()
response = client.beta.messages.create(
    model=os.environ["ANTHROPIC_MODEL"],
    max_tokens=2048,
    betas=["mcp-client-2025-11-20"],
    mcp_servers=[{
        "type": "url",
        "url": os.environ["LOCUS_MCP_URL"],
        "name": "locus_pro",
        "authorization_token": os.environ["LOCUS_AGENT_CONNECTION"],
    }],
    tools=[{
        "type": "mcp_toolset",
        "mcp_server_name": "locus_pro",
    }],
    messages=[{
        "role": "user",
        "content": "Search for the requested evidence and summarize it.",
    }],
)

import os
from claude_agent_sdk import ClaudeAgentOptions

options = ClaudeAgentOptions(
    mcp_servers={
        "locus_pro": {
            "type": "http",
            "url": os.environ["LOCUS_MCP_URL"],
            "headers": {
                "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
            },
        }
    },
)

import os
from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model=os.environ["GEMINI_MODEL"],
    input="Use the approved Locus tools to research this request.",
    tools=[{
        "type": "mcp_server",
        "name": "locus_pro",
        "url": os.environ["LOCUS_MCP_URL"],
        "headers": {
            "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
        },
    }],
)

print(interaction.output_text)

pip install langchain langchain-mcp-adapters

import asyncio
import os
from langchain.agents import create_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

async def main() -> None:
    client = MultiServerMCPClient({
        "locus_pro": {
            "transport": "http",
            "url": os.environ["LOCUS_MCP_URL"],
            "headers": {
                "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
            },
        }
    })

    tools = await client.get_tools()
    agent = create_agent(
        model=os.environ["LANGCHAIN_MODEL"],
        tools=tools,
    )
    result = await agent.ainvoke({
        "messages": [{
            "role": "user",
            "content": "Research the requested topic with the approved tools.",
        }]
    })
    print(result)

asyncio.run(main())

import { mcp } from "@llamaindex/tools";
import { llamaIndexTSMcpServer } from "@withlocus/credits";

const server = mcp(llamaIndexTSMcpServer(connection));

try {
  const tools = await server.tools();
  // Pass `tools` to agent() from @llamaindex/workflow.
} catch (error) {
  console.error("LlamaIndex could not load Locus tools", error);
  throw error;
} finally {
  await server.cleanup();
}

import asyncio
import os
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import (
    McpWorkbench,
    StreamableHttpServerParams,
)

async def main() -> None:
    server = StreamableHttpServerParams(
        url=os.environ["LOCUS_MCP_URL"],
        headers={
            "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
        },
    )
    model = OpenAIChatCompletionClient(model=os.environ["OPENAI_MODEL"])

    async with McpWorkbench(server_params=server) as workbench:
        agent = AssistantAgent(
            "locus_research_agent",
            model_client=model,
            workbench=workbench,
            reflect_on_tool_use=True,
        )
        result = await agent.run(
            task="Research the request with the approved Locus tools."
        )
        print(result.messages[-1])

    await model.close()

asyncio.run(main())

import asyncio
import os
import httpx
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client

async def main() -> None:
    headers = {
        "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
    }
    async with httpx.AsyncClient(headers=headers) as http:
        async with streamable_http_client(
            os.environ["LOCUS_MCP_URL"],
            http_client=http,
        ) as (read_stream, write_stream):
            async with ClientSession(read_stream, write_stream) as session:
                await session.initialize()
                tools = await session.list_tools()
                print([tool.name for tool in tools.tools])

asyncio.run(main())