BrinqaIQ MCP

BrinqaIQ's Model Context Protocol (MCP) integration lets you use any MCP-compatible AI client — such as Claude Desktop, GitHub Copilot in VS Code, or Goose — to query Brinqa Platform data, generate BQL, explore CVEs, and search documentation without leaving your existing tooling.

What is MCP?

MCP is an open standard that enables AI applications to securely connect to external data sources and tools. It provides a universal way for AI systems to access contextual information, allowing them to interact with various platforms and services through a standardized interface.

By implementing MCP, BrinqaIQ enables you to use compatible AI clients (like Claude Desktop, Visual Studio Code, and other MCP-enabled applications) to interact with BrinqaIQ capabilities such as writing BQL queries, exploring CVEs, and accessing documentation.

Available Tools

BrinqaIQ MCP exposes the following capabilities through the tool registry. All six are available to every connected MCP client.

Table 1: BrinqaIQ MCP capabilities

Capability	What you can do
BQL generation	Generate BQL queries from natural language descriptions of what data you want.
BQL execution	Run BQL queries and retrieve paginated results, useful for feeding Brinqa data into external agent pipelines.
Docs Assistant	Search and retrieve content from Brinqa Platform documentation.
CVE Explorer	Look up CVE details, severity, affected products, and remediation context.
Automation lifecycle	Launch, resume, cancel, and check the status of automations and flows.
Flows and automations discovery	List all flows and automations, inspect by name or ID, and list currently running flows.

For the full interactive API reference — including parameters, request/response schemas, and authentication requirements — go to:

https://<your-brinqa-platform-url>/brinqamax/docs

Security and Access Control

The BrinqaIQ MCP integration uses API token-based authentication to access Brinqa Platform on your behalf. MCP only accesses the specific BrinqaIQ endpoints documented in the Available Tools section above, and all other Brinqa Platform APIs are not accessible through the MCP integration.

All API calls made through MCP inherit the permissions of the user account associated with their API token, including any role-based or data-level access controls. This ensures that MCP can only access data that the user already has permission to view in the Brinqa Platform.

Supported AI Clients

The following AI platforms have been tested and are known to operate successfully with the BrinqaIQ MCP Server:

• Claude Desktop
• GitHub Copilot in VS Code
• Goose
• Open WebUI

note

Brinqa does not provide official support for third-party AI clients. Compatibility depends on each client's implementation of the MCP standard and may vary.

Connect Claude Desktop to BrinqaIQ MCP

This section demonstrates how to connect Claude Desktop to BrinqaIQ MCP.

Prerequisites

Before connecting to BrinqaIQ MCP, you must have these prerequisites in place:

• A Brinqa API key

  Generate a Brinqa API key in the Brinqa Platform UI. The API key authenticates your MCP client with the Brinqa Platform.

• Claude Desktop application

  Download and install Claude Desktop from claude.ai/download.

• Python package manager (uv)

  uv is a Python package and project manager. For installation instructions, see the uv documentation.

  After installing uv, find the full path to uvx by running this command in your terminal:

  which uvx

  Save this path for the MCP server configuration.

Configure the MCP Server

After installing the prerequisites, configure Claude Desktop to connect to BrinqaIQ MCP by adding your Brinqa Platform URL and API key to its MCP settings file.

To configure the MCP server in Claude Desktop, follow these steps:

1. Open Claude on your machine.

2. Click your profile icon in the bottom-left corner of the sidebar.

3. Click Settings and then Developer.

4. Click Edit Config.

5. If prompted, select a text editor to open the claude_desktop_config.json file.

6. Add this configuration to the file:

   {
     "mcpServers": {
       "brinqaMCP": {
         "command": "<your-uvx-path>",
         "args": [
           "mcp-openapi-proxy"
         ],
         "env": {
           "OPENAPI_SPEC_URL": "https://<your-brinqa-platform-url>/brinqamax/openapi.json",
           "API_KEY": "<your-brinqa-platform-access-token>"
         }
       }
     }
   }

   Replace <your-uvx-path> and <your-brinqa-platform-url> with your actual values, and replace <your-brinqa-platform-access-token> with your Brinqa API key.

   note

   The configuration uses mcp-openapi-proxy, a Python package that implements an MCP server using the OpenAPI specification.

7. Save the file.

8. Restart Claude.

Test the Connection

After Claude Desktop restarts successfully, test the connection:

1. Open Claude.

2. Ask a question related to BrinqaIQ, such as "Are you connected to BrinqaIQ MCP?".

3. The MCP server should connect automatically and provide an answer.

   

Connect GitHub Copilot to BrinqaIQ MCP

This section demonstrates how to connect GitHub Copilot in VS Code to BrinqaIQ MCP.

Prerequisites

Before connecting to BrinqaIQ MCP, you must have these prerequisites in place:

• A Brinqa API key

  Generate a Brinqa API key in the Brinqa Platform UI. The API key authenticates your MCP client with the Brinqa Platform.

• GitHub Copilot extension in VS Code

  Download and install the GitHub Copilot extension:

  1. Open VS Code.
  2. Go to Extensions and search for "GitHub Copilot".
  3. Click Install.

  GitHub Copilot offers a free plan for individuals with limited access, as well as paid plans. For more information, see GitHub Copilot plans.

• Python package manager (uv)

  uv is a Python package and project manager. For installation instructions, see the uv documentation.

  After installing uv, find the full path to uvx by running this command in your terminal:

  which uvx

  Save this path for the MCP server configuration.

Configure the MCP Server

After installing the prerequisites, configure Copilot to connect to BrinqaIQ MCP by adding your Brinqa Platform URL and API key to its MCP settings file.

To configure the MCP server in VS Code, follow these steps:

1. Open your workspace in VS Code.

2. Create a .vscode folder in your workspace root if it doesn’t already exist.

3. Create a file named mcp.json in the .vscode folder.

4. Add this configuration to the file:

   {
     "servers": {
       "brinqaMCP": {
         "type": "stdio",
         "command": "<your-uvx-path>",
         "args": [
           "mcp-openapi-proxy"
         ],
         "env": {
           "OPENAPI_SPEC_URL": "https://<your-brinqa-platform-url>/brinqamax/openapi.json",
           "API_KEY": "<your-brinqa-platform-access-token>",
           "OPENAPI_SIMPLE_MODE": "true"
         }
       }
     }
   }

   Replace <your-uvx-path> and <your-brinqa-platform-url> with your actual values, and replace <your-brinqa-platform-access-token> with your Brinqa API key.

   note

   The configuration uses mcp-openapi-proxy, a Python package that implements an MCP server using the OpenAPI specification.

5. Save the file.

6. In VS Code, you should see clickable actions (code lenses) above the server configuration in mcp.json. Click Start to start the MCP server.

7. If prompted, confirm that you trust the MCP server configuration.

This configuration creates a workspace-level MCP server that only applies to the current workspace. For other configuration options (user-level, dev container, or automatic discovery), see the VS Code MCP documentation.

Test the Connection

After the MCP server starts successfully, test the connection:

1. Open Copilot Chat in VS Code.

2. Ask a question related to BrinqaIQ, such as "Are you connected to BrinqaIQ MCP?" or "What BrinqaIQ tools are available?".

3. Copilot should respond using the BrinqaIQ MCP tools.

To view the MCP server logs or troubleshoot issues:

1. Open the Output panel (View > Output).
2. Select MCP: brinqaMCP from the dropdown menu.
3. Review any error messages or connection logs.

Connect Goose to BrinqaIQ MCP

This section demonstrates how to connect Goose to BrinqaIQ MCP.

Prerequisites

Before connecting to BrinqaIQ MCP, you must have these prerequisites in place:

• A Brinqa API key

  Generate a Brinqa API key in the Brinqa Platform UI. The API key authenticates your MCP client with the Brinqa Platform.

• Goose

  Download and install Goose following the instructions in the Goose documentation. Goose is available as a desktop application or CLI tool.

• Language model provider

  Goose requires a language model to process queries and interact with BrinqaIQ tools. Configure a language model provider (such as Ollama, GitHub Copilot, OpenAI, or other compatible providers) following the Goose documentation.

• Python package manager (uv)

  uv is a Python package and project manager. For installation instructions, see the uv documentation.

  After installing uv, you can use uvx directly if it's in your system PATH, or use the full path. To find the full path, run:

  which uvx

  In the configuration steps below, you can use either uvx or the full path returned by this command.

Configure the MCP Extension

After installing the prerequisites, configure Goose to connect to BrinqaIQ MCP by creating an extension.

To configure the MCP extension in Goose, follow these steps:

1. Open Goose Desktop.

2. Go to Extensions and click Add custom extension.

3. Configure the extension with these settings:

   • Name: BrinqaMCP
   • Type: STDIO
   • Command: <your-uvx-path> mcp-openapi-proxy
   • Environment Variables:
     • API_KEY = <your-brinqa-api-key>
     • OPENAPI_SPEC_URL = https://<your-brinqa-platform-url>/brinqamax/openapi.json

   Replace <your-uvx-path> and <your-brinqa-platform-url> with your actual values, and replace <your-brinqa-api-key> with your Brinqa API key.

   note

   The configuration uses mcp-openapi-proxy, a Python package that implements an MCP server using the OpenAPI specification.

4. Click Add Extension.

Test the Connection

After configuring the MCP extension, test the connection:

1. In Goose, start a new chat.

2. Ask a question related to BrinqaIQ, such as "Are you connected to BrinqaIQ MCP?" or "What BrinqaIQ tools are available?".

   Goose should respond using the BrinqaIQ MCP tools.

tip

Using MCP extensions with local language models (like Ollama) requires significant computational resources. If you experience timeouts or slow responses, consider using a cloud-based provider (like OpenAI or GitHub Copilot) or a machine with more available resources.

If the connection is not working, verify:

• Your language model provider is configured correctly.
• The BrinqaMCP extension is saved and enabled in Goose.
• The API key entered is correct.
• The Brinqa Platform URL is accessible from your machine.
• Check Goose logs for detailed error messages.

Connect Open WebUI to BrinqaIQ

This section demonstrates how to connect Open WebUI to BrinqaIQ using OpenAPI integration.

Prerequisites

Before connecting to BrinqaIQ, you must have these prerequisites in place:

• A Brinqa API key

  Generate a Brinqa API key in the Brinqa Platform UI. You will supply this key in the connection headers when configuring Open WebUI.

• Open WebUI

  Install Open WebUI following the instructions in the Open WebUI documentation. Once installed, start Open WebUI and access it in your browser (typically at http://localhost:8080).

• Language model

  Open WebUI requires a language model to process queries and interact with BrinqaIQ tools. You can use various LLM backends such as Ollama, OpenAI, or other compatible providers. For language model setup instructions, see the Open WebUI documentation.

  If using Ollama, smaller models like llama3.2:3b provide faster responses while still effectively utilizing BrinqaIQ tools.

Configure the OpenAPI Connection

After installing the prerequisites, configure Open WebUI to connect to BrinqaIQ by adding an OpenAPI connection.

note

Open WebUI connects to BrinqaIQ through its OpenAPI specification rather than through MCP's stdio transport. This is due to Open WebUI's web-based, multi-tenant architecture.

To configure the connection in Open WebUI, follow these steps:

1. Access Open WebUI in your browser (typically http://localhost:8080).

2. Click your user icon in the top-right corner.

3. Click Settings, and then Admin Settings.

4. Go to External Tools and click + (Add Connection).

5. Configure the connection with these settings:

   • Type: OpenAPI
   • URL: https://<your-brinqa-platform-url>
   • OpenAPI Spec:
     • URL: brinqamax/openapi.json
     • Auth: None
   • Headers:

     {
       "Authorization": "Bearer <your-brinqa-platform-access-token>"
     }

   • Name: BrinqaMCP
   • Description: BrinqaIQ API integration
   • Visibility: Public

   Replace <your-brinqa-platform-url> with your Brinqa Platform URL and <your-brinqa-platform-access-token> with your Brinqa API key.

6. Click Save.

Ensure the connection toggle is enabled (switched on).

Test the Connection

After configuring the OpenAPI connection, test it to verify BrinqaIQ tools are available:

1. In Open WebUI, start a new chat.

2. Select your language model from the model dropdown (e.g., llama3.2:3b).

3. At the bottom of the message input field, select Integrations > Tools > BrinqaMCP.

   This directs the language model to use the BrinqaIQ connection when responding to your query.

4. Ask a question to test the BrinqaIQ connection, such as "What tools does BrinqaIQ support?" or "Can you query BrinqaIQ data models?".

   The model should respond by accessing BrinqaIQ tools and providing information about available capabilities.

   

If the connection is not working, verify:

• Your language model backend is running (if using Ollama, run ollama list to check installed models)
• The OpenAPI connection is enabled in Open WebUI.
• The Brinqa API key in the Authorization header is correct.
• The Brinqa Platform URL is accessible from your machine.