> ## 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/inference.svg",
    keywords: ["provider", "google", "vertex", "gemini", "claude"],
  },
  {
    title: "Amazon Bedrock",
    href: "/integrations/model-providers/amazon-bedrock",
    category: "model-providers",
    logo: "/images/integrations/logos/inference.svg",
    keywords: ["provider", "aws", "bedrock", "openai compatible", "claude"],
  },
  {
    title: "Google Gemini",
    href: "/integrations/model-providers/google-gemini",
    category: "model-providers",
    logo: "/images/integrations/logos/inference.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/inference.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/inference.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/inference.svg",
    keywords: ["agents", "voice", "realtime", "livekit", "otel"],
  },
  {
    title: "ElevenLabs Agents",
    href: "/integrations/traces/elevenlabs",
    category: "agents",
    logo: "/images/integrations/logos/inference.svg",
    keywords: ["agents", "voice", "conversation", "elevenlabs"],
  },
  {
    title: "Vercel Eve",
    href: "/integrations/traces/eve",
    category: "agents",
    logo: "/images/integrations/logos/inference.svg",
    keywords: ["agents", "eve", "vercel", "ai sdk", "tools"],
  },
  {
    title: "Cursor SDK",
    href: "/integrations/traces/cursor-sdk",
    category: "agents",
    logo: "/images/integrations/logos/inference.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.