Give your agent its own cloud.

An agent you build with an SDK connects like any MCP client, with an API key instead of a browser sign-in:

Create a key on the dashboard's Agents page, with the budget the agent may spend.
Keep it in BRIQ_API_KEY.
Point your framework at https://api.briq.cloud/mcphttps://api.stg.briq.cloud/mcphttp://localhost:3001/mcp (Streamable HTTP), with the key as an Authorization: Bearer header.

Each snippet below does step 3; replace <your model> with yours.

Using a coding agent or a chat app instead? See Clients.

Claude Agent SDK

npm i @anthropic-ai/claude-agent-sdk (or pip install claude-agent-sdk)

import { query } from '@anthropic-ai/claude-agent-sdk';

for await (const m of query({
  prompt: 'Start a Postgres on briq',
  options: {
    mcpServers: {
      briq: {
        type: 'http',
        url: 'https://api.briq.cloud/mcp',
        headers: { Authorization: `Bearer ${process.env.BRIQ_API_KEY}` },
      },
    },
    allowedTools: ['mcp__briq__*'],
  },
})) if (m.type === 'result' && m.subtype === 'success') console.log(m.result);

allowedTools is what lets the agent call briq's tools without asking. A server that fails to authenticate does not throw: it shows as failed or needs-auth in the init message.

OpenAI Agents SDK

pip install openai-agents (or npm i @openai/agents)

import os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(
    name="briq",
    params={
        "url": "https://api.briq.cloud/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['BRIQ_API_KEY']}"},
    },
    cache_tools_list=True,
) as briq:
    agent = Agent(name="Ops", instructions="Use briq for services.", mcp_servers=[briq])
    print((await Runner.run(agent, "Start a Postgres on briq")).final_output)

In JavaScript, new MCPServerStreamableHttp({ name: 'briq', url, requestInit: { headers } }), then await briq.connect() before running the agent.

Vercel AI SDK

npm i ai @ai-sdk/mcp

import { createMCPClient } from '@ai-sdk/mcp';
import { ToolLoopAgent } from 'ai';

const briq = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://api.briq.cloud/mcp',
    headers: { Authorization: `Bearer ${process.env.BRIQ_API_KEY}` },
  },
});
try {
  const agent = new ToolLoopAgent({ model: '<your model>', tools: await briq.tools() });
  console.log((await agent.generate({ prompt: 'Start a Postgres on briq' })).text);
} finally {
  await briq.close();
}

LangChain and LangGraph

pip install "langchain[mcp]" (or npm i langchain @langchain/mcp-adapters)

import os
from fastmcp.client import Client
from langchain.agents import create_agent
from langchain.mcp import MCPAdapter

async with MCPAdapter(Client("https://api.briq.cloud/mcp", auth=os.environ["BRIQ_API_KEY"])) as briq:
    agent = create_agent("<your model>", await briq.list_tools())
    await agent.ainvoke({"messages": [{"role": "user", "content": "Start a Postgres on briq"}]})

auth= sends the key as a Bearer token. In JavaScript: new MCPAdapter({ servers: { briq: { url, headers } } }), then await adapter.listTools(). The older MultiServerMCPClient from langchain-mcp-adapters still works with "transport": "http" and "headers".

Mastra

npm i @mastra/mcp @mastra/core

import { Agent } from '@mastra/core/agent';
import { MCPClient } from '@mastra/mcp';

const mcp = new MCPClient({
  servers: {
    briq: {
      url: new URL('https://api.briq.cloud/mcp'),
      requestInit: { headers: { Authorization: `Bearer ${process.env.BRIQ_API_KEY}` } },
    },
  },
});

export const agent = new Agent({
  id: 'ops',
  name: 'Ops',
  instructions: 'Use briq for services.',
  model: '<your model>',
  tools: await mcp.listTools(),
});

Pydantic AI

pip install "pydantic-ai-slim[mcp]"

import os
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPToolset

briq = MCPToolset(
    "https://api.briq.cloud/mcp",
    headers={"Authorization": f"Bearer {os.environ['BRIQ_API_KEY']}"},
)
agent = Agent("<your model>", toolsets=[briq])

async def main():
    async with agent:
        print((await agent.run("Start a Postgres on briq")).output)

Google ADK

pip install google-adk

import os
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

root_agent = LlmAgent(
    model="<your model>",
    name="ops",
    instruction="Use briq for services.",
    tools=[McpToolset(connection_params=StreamableHTTPConnectionParams(
        url="https://api.briq.cloud/mcp",
        headers={"Authorization": f"Bearer {os.environ['BRIQ_API_KEY']}"},
    ))],
)

CrewAI

pip install crewai mcp

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

agent = Agent(
    role="Ops",
    goal="Run the services the crew needs",
    backstory="Runs databases and apps on briq.",
    mcps=[MCPServerHTTP(
        url="https://api.briq.cloud/mcp",
        headers={"Authorization": f"Bearer {os.environ['BRIQ_API_KEY']}"},
        streamable=True,
    )],
)

Anything else

Any MCP client library works the same way: Streamable HTTP to the URL above, with the key in an Authorization: Bearer header. Without MCP, every tool is also a REST call.

Frameworks