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

# Connections

> Configure the shared LLM, external MCP, HTTP, and vector store credentials that Streamkap streaming agents and knowledge bases use

Connections are saved, encrypted credentials shared across every agent in your organization (all projects). You define them once on the **Connections** tab, and agents and knowledge bases reference them by name, so keys aren't re-entered per agent, and rotating a credential in one place updates everything that uses it.

An **LLM connection is required** before you can build an agent. The other connection types are optional and depend on what your agents do. Where available, Streamkap also provides two managed default connections you can use for quick tests without bringing your own keys — see [Streamkap Default Connections](#streamkap-default-connections).

<Info>
  Secrets are encrypted at rest and masked when you view a connection. Read-only users (`read:agents`) can see connections with keys masked but cannot edit them; saving requires `write:agents`.
</Info>

## LLM Connections

An LLM connection holds a model provider's credentials and defaults. It's the identity an agent's model uses, and the embedding model a knowledge base uses.

Each connection declares one or both **capabilities** — **Chat** (used by agents to run the model) and **Embedding** (used by knowledge bases and long-term memory to embed text):

| Provider               | Chat | Embedding | Notes                                                                                                                                    |
| ---------------------- | :--: | :-------: | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **Anthropic**          |   ✓  |     —     | Claude models. Supports a custom base URL for Anthropic-compatible proxies (LiteLLM, enterprise gateways).                               |
| **OpenAI**             |   ✓  |     ✓     | GPT and `text-embedding-*` models. Supports a custom base URL for self-hosted OpenAI-compatible servers (vLLM, LocalAI, TGI, LM Studio). |
| **OpenAI (Responses)** |   ✓  |     —     | OpenAI's Responses API for reasoning models. Embeddings still go through the plain OpenAI provider.                                      |
| **Azure**              |   ✓  |     ✓     | Azure AI Studio. Requires your Azure base URL.                                                                                           |
| **Azure OpenAI**       |   ✓  |     —     | Azure OpenAI via the OpenAI SDK. Requires the Azure endpoint and an API version.                                                         |
| **Ollama**             |   ✓  |     ✓     | Self-hosted. Requires the server base URL.                                                                                               |
| **AWS Bedrock**        |   ✓  |     ✓     | No API key — authenticates with AWS IAM credentials; you set the region.                                                                 |
| **Qwen**               |   —  |     ✓     | Embedding-only (DashScope-compatible).                                                                                                   |
| **OpenAI-compatible**  |   —  |     ✓     | Embedding-only; any host exposing a `/v1/embeddings` endpoint.                                                                           |

<Steps>
  <Step title="Add a connection">
    On the **Connections** tab, open **LLM Connections** and add a row. Enter a **Name** and pick a **Provider**, then paste the provider **API key** (Bedrock uses IAM credentials instead). For a self-hosted or proxy endpoint, enable the custom base URL and set it.
  </Step>

  <Step title="Test">
    Click **Test**. Streamkap validates the key against the provider and loads the live model list — the model dropdown is always fetched live from your provider, so new model releases show up without waiting for a Streamkap update.
  </Step>

  <Step title="Set capabilities and defaults">
    Choose the **Chat** and/or **Embedding** capabilities, then set defaults — chat model, temperature, max tokens, and timeout; embedding model for embedding connections. Agents can override these per agent.
  </Step>
</Steps>

## External MCP Servers

An external MCP connection lets an agent call tools exposed by an MCP server you host. Configure a **Name**, an **Auth mode** (None, Bearer token, or Custom header), and the **Server URL**, then click **Test** to discover the tools the server exposes.

<Warning>
  External MCP server URLs must be **HTTPS on port 443**. Streamkap rejects private, loopback, and cloud-metadata addresses, and blocks unsafe headers (for example `Authorization` in custom-header mode, `Cookie`, and `Host`).
</Warning>

To let an agent operate your *own* Streamkap platform instead, use the **Streamkap MCP** tool — see [Streamkap MCP](#streamkap-mcp) below.

## HTTP Connections

An HTTP connection stores a reusable base URL and headers for **HTTP tools**. Define it once (name, base URL, headers, description) and select it when adding an HTTP tool to an agent, so the tool inherits the endpoint and auth without re-entering them.

## Vector Stores

A vector store connection is where knowledge base embeddings and long-term memory are written and read. Pick a **Provider** and fill in its fields:

| Provider                | Fields                                                                                                                                         |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| **Pinecone**            | API key, index host, optional default namespace                                                                                                |
| **pgvector (Postgres)** | JDBC URL (`jdbc:postgresql://host:5432/db`), username, password, table (auto-created on first deploy), optional dimensions and distance metric |
| **Milvus**              | URI (or host + port), token (or username + password)                                                                                           |
| **Amazon OpenSearch**   | Endpoint and index, plus provider properties                                                                                                   |
| **Elasticsearch**       | Index and vector field, plus provider properties                                                                                               |
| **Amazon S3 Vectors**   | Vector bucket and vector index, plus provider properties                                                                                       |

<Note>
  For pgvector, don't embed credentials in the JDBC URL — put them in the username and password fields. Dimensions must match your embedding model's output; leave blank to inherit it.
</Note>

## Streamkap Default Connections

Where available, two Streamkap-managed rows appear alongside your own connections, marked with a **Streamkap Default** badge:

* **Streamkap Default LLM** — a managed chat + embedding model. Available for quick tests without bringing your own key; not intended for production data. Rate limits and model choice may change.
* **Streamkap Default Vector Store** — a managed vector index. Available for quick tests; not intended for production data.

They let you deploy a working agent or knowledge base before you've set up any credentials of your own — select them anywhere a connection is picked (the agent wizard's Model step, a knowledge base's embedding model and vector store). They are read-only: the keys are managed by Streamkap, never displayed, and the rows can't be edited or deleted.

<Note>
  Data written to the default vector store is isolated automatically — each organization (and each knowledge base) gets its own namespace on the managed index. You can't choose the namespace yourself. For production workloads, bring your own LLM and vector store connections.
</Note>

## Streamkap MCP

Streamkap MCP lets an agent operate your Streamkap platform — inspecting topics, checking pipeline status, and looking up schemas — as a tool during a run. It isn't a connection on this tab; it's authenticated by an **agentic-enabled [Project Key](/project-keys)**.

Enable **Use with agents** on a Project Key (see [Use with Streaming Agents](/project-keys#use-with-streaming-agents)), then select it when adding the **Streamkap MCP** tool to an agent (see [Build an Agent](/streaming-agents-build#tools)). The key's [MCP tool scoping](/project-keys#step-3-mcp-scoping) restricts which platform tools the agent can call.

<Warning>
  Disabling **Use with agents** on a Project Key breaks any agent bound to that key. Re-enable it or point the agent at another agentic-enabled key.
</Warning>

## Related

* [Build an Agent](/streaming-agents-build) — reference these connections when configuring an agent
* [Knowledge Bases](/streaming-agents-knowledge-bases) — use embedding and vector store connections
* [Project Keys](/project-keys) — credentials and MCP tool scoping