Framework integrations

export LOCUS_AGENT_CONNECTION="lcac_...copy once..."
export LOCUS_MCP_URL="https://api.paywithlocus.com/api/credits/mcp"

const connection = await locus.agentConnections.create({
  name: "research-agent-prod",
  mode: "platform",
  tools: { enable: ["tavily/search", "firecrawl/scrape"] },
  maxCreditsPerCall: "250",
  maxCreditsPerLoop: "1500",
  expiresIn: "30d",
});

await saveSecret({
  token: connection.credential,
  url: connection.mcp.url,
});

npm install ai @ai-sdk/mcp @withlocus/credits

import { createMCPClient } from "@ai-sdk/mcp";
import {
  LocusCredits,
  vercelAIMcpTransport,
} from "@withlocus/credits";

const locus = new LocusCredits(process.env.LOCUS_SECRET_KEY!, {
  baseUrl: "https://api.paywithlocus.com",
});
const connection = await locus.agentConnections.create({
  name: "vercel-research-prod",
  mode: "platform",
  tools: { enable: ["tavily/search", "firecrawl/scrape"] },
  maxCreditsPerCall: "250",
  maxCreditsPerLoop: "1500",
  expiresIn: "30d",
});

const mcp = await createMCPClient({
  transport: vercelAIMcpTransport(connection),
});

try {
  const tools = await mcp.tools();
  // Pass `tools` to generateText(), streamText(), or an Agent.
} catch (error) {
  console.error("Locus MCP connection failed", error);
  throw error;
} finally {
  await mcp.close();
}

const mcp = await createMCPClient({
  transport: {
    type: "http",
    url: process.env.LOCUS_MCP_URL!,
    headers: {
      Authorization: `Bearer ${process.env.LOCUS_AGENT_CONNECTION!}`,
    },
  },
});

pip install "google-adk[mcp]"

import os
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import (
    StreamableHTTPConnectionParams,
)

locus_tools = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url=os.environ["LOCUS_MCP_URL"],
        headers={
            "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
        },
    )
)

agent = LlmAgent(
    name="locus_research_agent",
    model=os.environ["GEMINI_MODEL"],
    instruction="Use only the approved Locus tools.",
    tools=[locus_tools],
)

pip install "llama-index-tools-mcp<0.5" "mcp>=1.24,<2"

import os
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec

client = BasicMCPClient(
    os.environ["LOCUS_MCP_URL"],
    headers={
        "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
    },
)

tool_spec = McpToolSpec(client=client)
tools = await tool_spec.to_tool_list_async()

# Pass `tools` to FunctionAgent or another LlamaIndex workflow.

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();
}

pip install crewai

import os
from crewai import Agent
from crewai.mcp import MCPServerHTTP

researcher = Agent(
    role="Research analyst",
    goal="Find and synthesize evidence with approved APIs",
    backstory="A careful analyst with a bounded tool and credit budget.",
    mcps=[
        MCPServerHTTP(
            url=os.environ["LOCUS_MCP_URL"],
            headers={
                "Authorization": f"Bearer {os.environ['LOCUS_AGENT_CONNECTION']}"
            },
            streamable=True,
            cache_tools_list=True,
        )
    ],
)

pip install "autogen-agentchat" "autogen-ext[openai,mcp]" "mcp>=1.24,<2"

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())

npm install @mastra/mcp @withlocus/credits

import { MCPClient } from "@mastra/mcp";
import { mastraMcpServer } from "@withlocus/credits";

const mcp = new MCPClient({
  id: "locus-research-prod",
  servers: {
    locus_pro: mastraMcpServer(connection),
  },
});

try {
  const tools = await mcp.listTools();
  // Pass `tools` to a Mastra Agent.
} catch (error) {
  console.error("Mastra could not load Locus tools", error);
  throw error;
} finally {
  await mcp.disconnect();
}

const mcp = new MCPClient({
  servers: {
    locus_pro: {
      url: new URL(process.env.LOCUS_MCP_URL!),
      requestInit: {
        headers: {
          Authorization: `Bearer ${process.env.LOCUS_AGENT_CONNECTION!}`,
        },
      },
    },
  },
});

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { mcpHttpConnection } from "@withlocus/credits";

const config = mcpHttpConnection(connection);
const client = new Client({ name: "locus-agent", version: "1.0.0" });
const transport = new StreamableHTTPClientTransport(new URL(config.url), {
  requestInit: { headers: config.headers },
});

try {
  await client.connect(transport);
  const tools = await client.listTools();
  console.log(tools.tools.map((tool) => tool.name));
} catch (error) {
  console.error("Locus MCP request failed", error);
  throw error;
} finally {
  await client.close();
}

pip install "mcp>=2" httpx

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())