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

# Choose Your Integration

> Pick the right way to connect Nimble to your coding agent, your app, or your warehouse

Nimble offers four integration paths. All four reach the same APIs. The right one depends on where your agent runs and how you want to authenticate.

## Pick a path

| Path                | Best for                                 | Auth                                   | Start here                                                                                                                        |
| ------------------- | ---------------------------------------- | -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| **MCP server**      | Chat assistants and production agents    | **OAuth sign-in**, or an API key       | [MCP Server](/integrations/mcp-server/mcp-server)                                                                                 |
| **Plugin + Skills** | Coding agents with terminal access       | **OAuth sign-in**, or `NIMBLE_API_KEY` | [Plugin Installation](/integrations/agent-skills/plugin-installation)                                                             |
| **SDK + CLI**       | Application code that needs full control | `NIMBLE_API_KEY`                       | [Installation](/nimble-sdk/getting-started/installation)                                                                          |
| **Warehouse apps**  | Data teams working in SQL                | API key held in the warehouse          | [Databricks](/integrations/partnerships/databricks/marketplace-mcp), [Snowflake](/integrations/partnerships/snowflake/native-app) |

<Tip>
  Prefer OAuth where the client supports it. You sign in through the browser once and never handle a key, so there is nothing to paste, rotate, or leak. Tokens refresh automatically and you can revoke access at any time.
</Tip>

## Which path fits?

<Tabs>
  <Tab title="Coding agent">
    **Install the plugin.**

    If your agent runs in a terminal, the plugin is the most complete setup. It installs two things at once: Agent Skills, which teach your agent which Nimble product fits a given job, and a pre-configured MCP server connection.

    Skills matter more than they sound. Without them an agent knows the API exists but not when to reach for Extract Templates instead of Extract, or a Web Search Agent instead of Search. The skills encode those choices.

    [Plugin Installation](/integrations/agent-skills/plugin-installation) has a tab for each supported platform: Claude Code, Claude Cowork, Cursor, Codex, Cortex Code, and Vercel CLI.

    For any other terminal agent, [install the CLI](/nimble-sdk/sdks/cli) and set `NIMBLE_API_KEY`. The CLI reaches every product, including several the MCP server does not carry. See the coverage table below.
  </Tab>

  <Tab title="Chat assistant">
    **Use the MCP server, and sign in with OAuth.**

    Chat assistants like Claude have no terminal, so they cannot run the CLI. They connect to outside tools over MCP instead.

    Where the client supports OAuth, there is no key to handle at all. Click connect, approve the scopes in your browser, and the client stores and refreshes the token for you.

    | Client                     | Setup                                                                     |
    | -------------------------- | ------------------------------------------------------------------------- |
    | Claude Chat & CoWork       | [Claude Connectors](/integrations/connectors/anthropic/claude-connectors) |
    | VS Code and GitHub Copilot | [Azure MCP Center](/integrations/partnerships/microsoft/azure-mcp-center) |
    | Microsoft Copilot Studio   | [Copilot Studio](/integrations/partnerships/microsoft/copilot-studio)     |
    | Snowflake CoWork           | [Cortex Agents](/integrations/partnerships/snowflake/cortex-agents)       |

    For clients without OAuth support, point them at the server and pass a key instead:

    ```json theme={"system"}
    {
      "mcpServers": {
        "nimble": {
          "type": "http",
          "url": "https://mcp.nimbleway.com/mcp",
          "headers": { "Authorization": "Bearer NIMBLE_API_KEY" }
        }
      }
    }
    ```

    See [MCP Server](/integrations/mcp-server/mcp-server) for Claude Desktop, Cursor, and other clients.
  </Tab>

  <Tab title="Building an app">
    **Start with MCP for speed. Move to the SDK when you need control.**

    Both paths are production-ready, and they are not exclusive. Many teams start with MCP, then move specific tools to the SDK as requirements tighten.

    **MCP, fastest to ship.** OpenAI and Anthropic both accept a hosted MCP server URL directly in their APIs. Your model gets tool calling with no schemas to write or maintain.

    **SDK, full control.** Use the SDK when you need custom tool schemas, your own response shaping, or a product the MCP server does not carry.

    | Framework     | Guide                                                                                          |
    | ------------- | ---------------------------------------------------------------------------------------------- |
    | OpenAI        | [OpenAI connector](/integrations/connectors/openai)                                            |
    | Anthropic     | [Anthropic SDK](/integrations/connectors/anthropic/sdk)                                        |
    | LangChain     | [LangChain](/integrations/connectors/langchain)                                                |
    | LlamaIndex    | [LlamaIndex](/integrations/connectors/llamaindex)                                              |
    | Vercel AI SDK | [Vercel AI SDK](/integrations/connectors/vercel-ai-sdk)                                        |
    | Google ADK    | [Google ADK](/integrations/connectors/google-adk)                                              |
    | Any framework | [Python](/nimble-sdk/sdks/python), [Node](/nimble-sdk/sdks/node), or [Go](/nimble-sdk/sdks/go) |
  </Tab>

  <Tab title="Warehouse or SQL">
    **Install the warehouse app and call the web from SQL.**

    Nimble runs inside Databricks and Snowflake. Your API key stays in the warehouse, and results land as rows. No pipeline to build and no data leaves your account on the way in.

    | Warehouse  | Options                                                                                                                                                                                                     |
    | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | Databricks | [Marketplace MCP](/integrations/partnerships/databricks/marketplace-mcp), [Genie](/integrations/partnerships/databricks/genie), [Data enrichment](/integrations/partnerships/databricks/data-enrichment)    |
    | Snowflake  | [Native App](/integrations/partnerships/snowflake/native-app), [Cortex Agents](/integrations/partnerships/snowflake/cortex-agents), [Data enrichment](/integrations/partnerships/snowflake/data-enrichment) |

    Snowflake reads your key from a Snowflake Secret you control. Databricks takes it as a bearer token.
  </Tab>
</Tabs>

## What each path can reach

Coverage is not equal. Pick a path that carries the products you need.

| Product                                                     | Skills | MCP | SDK | CLI |
| ----------------------------------------------------------- | ------ | --- | --- | --- |
| [Search](/nimble-sdk/web-tools/search)                      | Yes    | Yes | Yes | Yes |
| [Extract](/nimble-sdk/web-tools/extract/quickstart)         | Yes    | Yes | Yes | Yes |
| [Extract Templates](/nimble-sdk/web-tools/extract/template) | Yes    | Yes | Yes | Yes |
| [Map](/nimble-sdk/web-tools/map)                            | Yes    | Yes | Yes | Yes |
| [Crawl](/nimble-sdk/web-tools/crawl)                        | Yes    | Yes | Yes | Yes |
| [Web Search Agents](/nimble-sdk/web-search-agents/overview) | Yes    | Yes | Yes | Yes |
| [SERP](/nimble-sdk/web-tools/serp)                          | No     | No  | Yes | Yes |
| [Media](/nimble-sdk/web-tools/media)                        | No     | No  | Yes | Yes |
| [Domain Knowledge](/nimble-sdk/web-tools/domain-knowledge)  | No     | No  | Yes | Yes |
| [Jobs](/nimble-sdk/agentic/jobs)                            | No     | No  | Yes | Yes |

## Authentication

Two mechanisms cover every path. Use OAuth where you can and an API key where you must.

### OAuth sign-in

The MCP server supports OAuth 2.1 with PKCE. Nothing to configure: the client discovers the flow from the server, opens your browser, and stores the token itself.

|                |                                                                              |
| -------------- | ---------------------------------------------------------------------------- |
| **Scopes**     | `nimble:read`, `nimble:write`, `offline_access`, `openid`                    |
| **Refresh**    | Handled by the client. `offline_access` keeps access alive between sessions. |
| **Revoke**     | Disconnect from the client, or revoke from your Nimble account.              |
| **Works with** | Claude, VS Code and GitHub Copilot, Copilot Studio, Cortex Code              |

Approving the consent screen grants permission to verify your identity, search the web, extract data, and manage Web Search Agents.

### API key

| Path                | How it works                                                                                                                   |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| **SDK + CLI**       | Set `NIMBLE_API_KEY`, or pass the key to the client constructor.                                                               |
| **MCP server**      | Pass the key as `Authorization: Bearer <key>` for clients without OAuth.                                                       |
| **Plugin + Skills** | Set `NIMBLE_API_KEY`. The CLI and skills read it automatically.                                                                |
| **Warehouse**       | Snowflake reads a Snowflake Secret. Databricks takes a bearer token.                                                           |
| **Proxy**           | Credentials go in the connection string, not a header. See [Proxy authentication](/nimble-sdk/web-tools/proxy/authentication). |

Get a key from [Settings → API Keys](https://online.nimbleway.com/settings/api-keys). Issue a separate key per project so you can revoke one without breaking the rest.

## Using more than one path

Most teams do. A plugin for local development, MCP for a chat assistant, and the SDK for production code all hit the same APIs with the same key.

## Next steps

<CardGroup cols={2}>
  <Card title="Plugin Installation" icon="rectangle-terminal" href="/integrations/agent-skills/plugin-installation">
    Install skills and MCP config in your coding agent
  </Card>

  <Card title="MCP Server" icon="server" href="/integrations/mcp-server/mcp-server">
    Give any AI agent live web access
  </Card>

  <Card title="Quickstart" icon="rocket" href="/nimble-sdk/getting-started/quickstart">
    Your first API call in under a minute
  </Card>

  <Card title="Connectors" icon="link-simple" href="/integrations/connectors/openai">
    Wire Nimble into your agent framework
  </Card>
</CardGroup>