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

# Integrations

> Connect Catalyst to your existing tooling, model providers, and frameworks.

export const gatewayCatalog = [{
  title: "Install with AI",
  href: "/integrations/install-with-ai",
  logo: "/images/integrations/logos/inference.svg",
  keywords: ["cli", "agent", "claude code", "opencode", "codex"]
}, {
  title: "MCP Server",
  href: "/integrations/mcp-server",
  logo: "/images/integrations/logos/inference.svg",
  keywords: ["mcp", "agent", "claude code", "cursor", "opencode", "codex"]
}, {
  title: "OpenAI",
  href: "/integrations/model-providers/openai",
  category: "model-providers",
  logo: "/images/integrations/logos/openai.svg",
  logoDark: "/images/integrations/logos/openai-dark.svg",
  keywords: ["provider", "chat completions"]
}, {
  title: "Anthropic",
  href: "/integrations/model-providers/anthropic",
  category: "model-providers",
  logo: "/images/integrations/logos/anthropic.svg",
  logoDark: "/images/integrations/logos/anthropic-dark.svg",
  keywords: ["provider", "claude"]
}, {
  title: "Vertex AI",
  href: "/integrations/model-providers/vertex-ai",
  category: "model-providers",
  logo: "/images/integrations/logos/googlecloud.svg",
  keywords: ["provider", "google", "vertex", "gemini", "claude"]
}, {
  title: "Amazon Bedrock",
  href: "/integrations/model-providers/amazon-bedrock",
  category: "model-providers",
  logo: "/images/integrations/logos/aws.svg",
  keywords: ["provider", "aws", "bedrock", "openai compatible", "claude"]
}, {
  title: "Google Gemini",
  href: "/integrations/model-providers/google-gemini",
  category: "model-providers",
  logo: "/images/integrations/logos/gemini.svg",
  keywords: ["provider", "google", "gemini", "generatecontent"]
}, {
  title: "OpenRouter",
  href: "/integrations/model-providers/openrouter",
  category: "model-providers",
  logo: "/images/integrations/logos/openrouter.svg",
  logoDark: "/images/integrations/logos/openrouter-dark.svg",
  keywords: ["provider", "openai compatible", "routing"]
}, {
  title: "Groq",
  href: "/integrations/model-providers/groq",
  category: "model-providers",
  logo: "/images/integrations/logos/groq.svg",
  keywords: ["provider", "latency"]
}, {
  title: "Cerebras",
  href: "/integrations/model-providers/cerebras",
  category: "model-providers",
  logo: "/images/integrations/logos/cerebras.svg",
  logoDark: "/images/integrations/logos/cerebras-dark.svg",
  keywords: ["provider", "inference"]
}, {
  title: "LangChain",
  href: "/integrations/frameworks/langchain",
  category: "frameworks",
  logo: "/images/integrations/logos/langchain.png",
  keywords: ["framework", "sdk", "agents"]
}];

export const gatewayRecommendedOrder = ["Install with AI", "MCP Server", "OpenAI", "Anthropic", "Vertex AI", "Amazon Bedrock", "Google Gemini", "OpenRouter", "Groq", "Cerebras", "LangChain"];

export const gatewayCategories = [{
  id: "all",
  label: "All"
}, {
  id: "model-providers",
  label: "Model providers"
}, {
  id: "frameworks",
  label: "Frameworks"
}];

export const tracesCatalog = [{
  title: "Quickstart",
  href: "/integrations/traces/quickstart",
  logo: "/images/integrations/logos/inference.svg",
  keywords: ["setup", "install", "first trace", "sdk"]
}, {
  title: "OpenAI",
  href: "/integrations/traces/openai",
  category: "providers",
  logo: "/images/integrations/logos/openai.svg",
  logoDark: "/images/integrations/logos/openai-dark.svg",
  keywords: ["provider", "chat completions", "responses", "tools"]
}, {
  title: "Anthropic",
  href: "/integrations/traces/anthropic",
  category: "providers",
  logo: "/images/integrations/logos/anthropic.svg",
  logoDark: "/images/integrations/logos/anthropic-dark.svg",
  keywords: ["provider", "claude", "messages", "prompt cache"]
}, {
  title: "Vercel AI SDK",
  href: "/integrations/traces/ai-sdk",
  category: "providers",
  logo: "/images/integrations/logos/vercel.svg",
  keywords: ["framework", "generatetext", "streamtext", "tool loop", "vercel"]
}, {
  title: "LangChain",
  href: "/integrations/traces/langchain",
  category: "frameworks",
  logo: "/images/integrations/logos/langchain.png",
  keywords: ["framework", "callbacks", "agents", "chains"]
}, {
  title: "LangGraph",
  href: "/integrations/traces/langgraph",
  category: "frameworks",
  logo: "/images/integrations/logos/langchain.png",
  keywords: ["framework", "graph", "nodes", "langchain"]
}, {
  title: "LangSmith",
  href: "/integrations/traces/langsmith",
  category: "frameworks",
  logo: "/images/integrations/logos/langchain.png",
  keywords: ["framework", "otel", "bridge", "traceable"]
}, {
  title: "Pydantic AI",
  href: "/integrations/traces/pydantic-ai",
  category: "frameworks",
  logo: "/images/integrations/logos/pydantic.svg",
  keywords: ["framework", "python", "pydantic", "agents"]
}, {
  title: "OpenAI Agents",
  href: "/integrations/traces/openai-agents",
  category: "agents",
  logo: "/images/integrations/logos/openai.svg",
  logoDark: "/images/integrations/logos/openai-dark.svg",
  keywords: ["agents", "handoffs", "tools", "openai"]
}, {
  title: "LiveKit Agents",
  href: "/integrations/traces/livekit-agents",
  category: "agents",
  logo: "/images/integrations/logos/livekit.svg",
  keywords: ["agents", "voice", "realtime", "livekit", "otel"]
}, {
  title: "ElevenLabs Agents",
  href: "/integrations/traces/elevenlabs",
  category: "agents",
  logo: "/images/integrations/logos/elevenlabs.svg",
  keywords: ["agents", "voice", "conversation", "elevenlabs"]
}, {
  title: "Vercel Eve",
  href: "/integrations/traces/eve",
  category: "agents",
  logo: "/images/integrations/logos/vercel.svg",
  keywords: ["agents", "eve", "vercel", "ai sdk", "tools"]
}, {
  title: "Cursor SDK",
  href: "/integrations/traces/cursor-sdk",
  category: "agents",
  logo: "/images/integrations/logos/cursor.svg",
  keywords: ["agents", "ide", "cursor", "tools"]
}, {
  title: "Claude Agent SDK",
  href: "/integrations/traces/claude-agent-sdk",
  category: "agents",
  logo: "/images/integrations/logos/anthropic.svg",
  logoDark: "/images/integrations/logos/anthropic-dark.svg",
  keywords: ["agents", "claude", "query", "anthropic"]
}, {
  title: "Claude Code SDK",
  href: "/integrations/traces/claude-code-sdk",
  category: "agents",
  logo: "/images/integrations/logos/anthropic.svg",
  logoDark: "/images/integrations/logos/anthropic-dark.svg",
  keywords: ["agents", "claude code", "cli", "subprocess", "anthropic"]
}, {
  title: "Manual spans",
  href: "/integrations/traces/manual-spans",
  category: "custom",
  logo: "/images/integrations/logos/inference.svg",
  keywords: ["custom", "agent span", "retriever", "tool", "router"]
}, {
  title: "Agent identity",
  href: "/integrations/traces/agent-identity",
  category: "custom",
  logo: "/images/integrations/logos/inference.svg",
  keywords: ["agent id", "agent name", "dashboard", "grouping"]
}];

export const tracesRecommendedOrder = ["Quickstart", "OpenAI", "Anthropic", "Vercel AI SDK", "LangChain", "LangGraph", "LangSmith", "Pydantic AI", "OpenAI Agents", "LiveKit Agents", "ElevenLabs Agents", "Vercel Eve", "Cursor SDK", "Claude Agent SDK", "Claude Code SDK", "Manual spans", "Agent identity"];

export const tracesCategories = [{
  id: "all",
  label: "All"
}, {
  id: "providers",
  label: "Providers"
}, {
  id: "frameworks",
  label: "Frameworks"
}, {
  id: "agents",
  label: "Agents"
}, {
  id: "custom",
  label: "Custom"
}];

export const IntegrationLogo = ({src, darkSrc}) => <div className="flex h-9 w-9 shrink-0 items-center justify-center mb-0 p-0 bg-white rounded-lg">
    <img src={src || darkSrc} alt="" aria-hidden="true" className={`block object-contain mb-0 p-1`} loading="lazy" />
  </div>;

export const IntegrationCard = ({integration}) => <a href={integration.href} className="group flex min-h-[80px] items-center gap-3 rounded-[28px] border border-gray-200 px-5 py-5 text-gray-950 transition hover:border-gray-300 hover:bg-white dark:border-gray-800 dark:text-white dark:hover:border-gray-700 dark:hover:bg-gray-900">
    <IntegrationLogo src={integration.logo} darkSrc={integration.logoDark} className={integration.logoClassName} />

    <div className="min-w-0 flex-1">
      <div className="truncate  font-medium tracking-tight text-gray-950 dark:text-white">
        {integration.title}
      </div>
    </div>

    <div className="flex h-8 w-8 shrink-0 items-center justify-center text-gray-400 transition group-hover:text-gray-600 dark:text-gray-500 dark:group-hover:text-gray-300">
      <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
        <path d="M7 17L17 7"></path>
        <path d="M8 7H17V16"></path>
      </svg>
    </div>

  </a>;

export const IntegrationGrid = ({items}) => <div className="grid grid-cols-1 gap-5 lg:grid-cols-2 xl:grid-cols-3">
    {items.map(integration => <IntegrationCard key={integration.href} integration={integration} />)}
  </div>;

export const sortByRecommendedOrder = (items, recommendedOrder) => [...items].sort((a, b) => {
  const aIndex = recommendedOrder.indexOf(a.title);
  const bIndex = recommendedOrder.indexOf(b.title);
  const aOrder = aIndex === -1 ? Infinity : aIndex;
  const bOrder = bIndex === -1 ? Infinity : bIndex;
  if (aOrder !== bOrder) {
    return aOrder - bOrder;
  }
  return a.title.localeCompare(b.title);
});

export const Catalog = ({items, categories, recommendedOrder, kind, emptyHelpText}) => {
  const [searchTerm, setSearchTerm] = React.useState("");
  const normalizedSearch = searchTerm.trim().toLowerCase();
  const categoryCounts = React.useMemo(() => {
    const counts = {
      all: items.length
    };
    items.forEach(integration => {
      if (integration.category) {
        counts[integration.category] = (counts[integration.category] || 0) + 1;
      }
    });
    return counts;
  }, [items]);
  const getFilteredIntegrations = categoryId => {
    const filtered = items.filter(integration => {
      const matchesCategory = categoryId === "all" || integration.category === categoryId;
      const keywords = (integration.keywords || []).join(" ").toLowerCase();
      const matchesSearch = !normalizedSearch || `${integration.title.toLowerCase()} ${keywords}`.includes(normalizedSearch);
      return matchesCategory && matchesSearch;
    });
    return sortByRecommendedOrder(filtered, recommendedOrder);
  };
  const searchResults = getFilteredIntegrations("all");
  return <>
      <div className="mb-6">
        <div className="integration-catalog-search-shell relative max-w-xl">
          <div className="integration-catalog-search-icon pointer-events-none absolute inset-y-0 left-0 flex items-center pl-4">
            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
              <circle cx="11" cy="11" r="8"></circle>
              <path d="m21 21-4.3-4.3"></path>
            </svg>
          </div>

          <input type="search" aria-label={`Search ${kind} integrations`} placeholder={`Search ${kind} integrations...`} value={searchTerm} onChange={event => setSearchTerm(event.target.value)} className="integration-catalog-search w-full rounded-2xl py-3 pl-11 pr-4 text-sm transition" />
        </div>
      </div>

      {!normalizedSearch ? <Tabs>
          {categories.map(category => <Tab key={category.id} title={`${category.label} (${categoryCounts[category.id] || 0})`}>
              <IntegrationGrid items={getFilteredIntegrations(category.id)} />
            </Tab>)}
        </Tabs> : searchResults.length ? <IntegrationGrid items={searchResults} /> : <div className="rounded-2xl border border-dashed border-gray-300 bg-gray-50 px-5 py-4 text-sm text-gray-700 dark:border-gray-700 dark:bg-gray-900 dark:text-gray-300">
          <p className="m-0 font-medium">No documented {kind} integrations match "{searchTerm}".</p>
          {emptyHelpText ? <p className="mt-2 mb-0">{emptyHelpText}</p> : null}
        </div>}
    </>;
};

export const GatewayCatalog = () => <Catalog items={gatewayCatalog} categories={gatewayCategories} recommendedOrder={gatewayRecommendedOrder} kind="gateway" emptyHelpText={<>Catalyst still supports additional OpenAI-compatible providers through <code>x-inference-provider-url</code>.</>} />;

export const TracesCatalog = () => <Catalog items={tracesCatalog} categories={tracesCategories} recommendedOrder={tracesRecommendedOrder} kind="tracing" emptyHelpText={<>Looking for a provider or framework that isn't listed? See <a href="/integrations/traces/manual-spans">Manual spans</a> for wrapping unsupported SDKs.</>} />;

Catalyst has three ways to connect with your stack. **Tracing integrations** use a lightweight SDK to collect the full shape of an LLM operation directly from your code, including agent runs, tool calls, framework steps, and spans you add yourself. **Gateway integrations** proxy your existing provider calls through Catalyst with a one-line base URL change, no SDK swap required. **MCP** connects compatible AI coding assistants to Catalyst resources with your project API key.

Browse the documented integrations below. If you do not see a gateway provider yet, Catalyst can still route many OpenAI-compatible endpoints through `x-inference-provider-url`.

**Jump to:** [Tracing integrations](#traces-integrations) · [Gateway integrations](#gateway-integrations) · [Routing headers](#routing-headers) · [OpenAI-compatible providers](#supported-openai-compatible-provider-urls)

## Traces Integrations

Traces integrations use the `@inference/tracing` (TypeScript) or `inference-catalyst-tracing` (Python) SDK to collect OpenInference-shaped spans directly from LLM SDKs, agent frameworks, and your own orchestration code. A single `setup()` call instruments the providers or frameworks you enable. Spans are exported over OTLP and grouped in Catalyst by service, trace, and task.

Use Traces when you need:

* Full agent run trees, not just individual requests
* Tool calls, tool results, and multi-step framework spans
* Visibility into work that never touches the Catalyst gateway (local models, custom routing, non-HTTP orchestration)

<Card title="Traces overview" icon="route" href="/integrations/traces/overview">
  Learn what gets captured and how to get started with Catalyst Tracing.
</Card>

### Browse Tracing Integrations

<TracesCatalog />

## Gateway Integrations

Gateway integrations route requests through the Catalyst gateway with a one-line base URL change. You keep your existing provider API keys. Your Catalyst project API key authenticates requests to the gateway, and a small set of headers control routing, environments, and task grouping.

Because requests flow through the gateway, Catalyst can measure performance metrics that are invisible to application code: time to first token (TTFT), tokens per second, and end-to-end latency across providers. These are captured automatically without any changes to your request logic.

<Card title="Gateway overview" icon="satellite-dish" href="/integrations/gateway/overview">
  Routing headers, supported providers, and the full Gateway setup reference.
</Card>

### Browse Gateway Integrations

<GatewayCatalog />

## Routing Headers

| Header                         | Required | Description                                                                                                                                                                                                             |
| ------------------------------ | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Authorization`                | Yes      | `Bearer <your-project-api-key>` authenticates the request to the gateway and links it to your project. For OpenAI-compatible SDKs, set this as the SDK's `apiKey`.                                                      |
| `x-inference-provider-api-key` | Yes      | Your provider API key or token, such as OpenAI, Bedrock, Groq, Gemini, or a Google Cloud Vertex credential. The gateway forwards it downstream. For Anthropic's native SDK, use `x-api-key` instead.                    |
| `x-inference-provider`         | No       | Forces routing to a specific provider, such as `openai`, `anthropic`, `gemini`, `vertex-ai`, or `cerebras`. Usually inferred from the SDK, path, or `x-inference-provider-url`; set it only to override that inference. |
| `x-inference-environment`      | No       | Tags requests with an environment, such as `production` or `staging`.                                                                                                                                                   |
| `x-inference-task-id`          | No       | Groups requests under a logical task for filtering and analytics.                                                                                                                                                       |
| `x-inference-provider-url`     | No       | Routes to any OpenAI-compatible provider by specifying its base URL. For Vertex native APIs, set this to the global or regional `aiplatform.googleapis.com` base URL.                                                   |

## Supported OpenAI-compatible Provider URLs

Any OpenAI-compatible provider can be used via the `x-inference-provider-url` header, even when it does not have a dedicated guide in the catalog yet.

| Provider       | Base URL                                                                                                                                                   |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| OpenAI         | `https://api.openai.com/v1`                                                                                                                                |
| OpenRouter     | `https://openrouter.ai/api`                                                                                                                                |
| Amazon Bedrock | `https://bedrock-mantle.{region}.api.aws/v1`                                                                                                               |
| Anthropic      | `https://api.anthropic.com/v1`                                                                                                                             |
| Google Gemini  | `https://generativelanguage.googleapis.com` for native Gemini paths; `https://generativelanguage.googleapis.com/v1beta/openai` for OpenAI-compatible calls |
| Vertex AI      | `https://aiplatform.googleapis.com/v1/projects/{project}/locations/global/endpoints/openapi`                                                               |
| Azure OpenAI   | `https://{resource}.openai.azure.com/openai/deployments/{deployment}`                                                                                      |
| Groq           | `https://api.groq.com/openai/v1`                                                                                                                           |
| Together AI    | `https://api.together.xyz/v1`                                                                                                                              |
| Fireworks AI   | `https://api.fireworks.ai/inference/v1`                                                                                                                    |
| Perplexity     | `https://api.perplexity.ai`                                                                                                                                |
| Mistral        | `https://api.mistral.ai/v1`                                                                                                                                |
| DeepSeek       | `https://api.deepseek.com/v1`                                                                                                                              |
| Cerebras       | `https://api.cerebras.ai/v1`                                                                                                                               |
| Inference.net  | `https://api.inference.net/v1`                                                                                                                             |

For regional Vertex AI endpoints, use `https://{location}-aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/endpoints/openapi` instead of the global host.