Skip to content
M↓ View as Markdown ↗

Actian MCP Server

The Actian Model Context Protocol (MCP) Server connects artificial intelligence (AI) applications to the Actian databases. By implementing the open-source MCP, the server acts as a secure bridge between an MCP-compatible AI client and the data source. It eliminates the need for custom integrations, allowing AI agents to discover capabilities, access metadata, and safely run database tasks through a standardized connection.

MCP is an open standard designed to connect AI models with external systems, tools, and data sources. When you use an Actian MCP Server, it provides the AI clients with three core building blocks:

Component Description Example
Tools Callable functions that the AI can invoke Running a specific SQL query
Resources Read-only data sources that the AI can access Viewing database schema information
Prompts Prebuilt templates designed for recurring tasks Reusing common database workflows

MCP Server Capabilities

You can use the Actian MCP Server to provide a single and unified interface for the Actian database management systems instead of building and maintaining separate connections for every AI client or workflow.

Depending on the configuration, the server enables AI clients to:

  • Run database queries using MCP tools.
  • Discover tables and other database objects.
  • Review schema details and metadata.
  • Use reusable prompts for database-oriented tasks.

The server also manages backend requirements, including transport, configuration, authentication, and secure database access.

MCP Server Advantages

By removing the need to build individual integrations for every AI use case, the Actian MCP Server provides a standardized way to use the trusted database capabilities. It ensures that deployment and access control remain securely managed at the server layer.

Architecture and Request Flow

Workflow

The Actian MCP Server sits between AI clients and the databases that they need to access.

%%{init: {
  'theme': 'default',
  'themeVariables': {'fontSize': '12px', 'fontFamily': 'arial'},
  'flowchart': {
    'subGraphTitleMargin': {'top': 8, 'bottom': 16},
    'padding': 15,
    'nodeSpacing': 50,
    'rankSpacing': 60
  }
}}%%
flowchart TB
    subgraph Clients["MCP Clients"]
        claude["Claude Desktop"]
        cursor["Cursor"]
        copilot["GitHub Copilot"]
        fastagent["fast-agent"]
        codex["Codex"]
        custom["Custom AI Agents"]
    end

    subgraph Transport["Transport Layer"]
        http["HTTP / SSE<br/>(Network)"]
    end

    subgraph Auth["Authentication"]
        idp["Identity Provider<br/>(Keycloak / Auth0)"]
        oauth["OAuth 2.0 / OIDC<br/>JWT Validation"]
    end

    subgraph MCP["Actian MCP Server"]
        direction TB
        core["MCP Protocol Handler"]
        tools["<b>Tools</b><br/>• Execute SQL Queries<br/>• List Tables and Views<br/>• Describe Table Schema<br/>• List Functions"]
        resources["<b>Resources</b><br/>• Schema Metadata<br/>• Table Definitions"]
        plugins["Database Plugins"]
        pool["Connection Pool"]
    end

    subgraph Databases["Actian Databases"]
        ae["Analytics Engine"]
        ingres["Ingres"]
        zen["Zen"]
        informix["HCL Informix®"]
        nosql["NoSQL"]
    end

    subgraph Security["Security Controls"]
        readonly["Query Mode<br/>(read-only by default)"]
        writegate["Write Gates<br/>(query_mode: read-write<br/>+ mcp:write scope<br/>+ human approval)"]
        impersonation["User Impersonation<br/>(SET SESSION AUTHORIZATION)"]
        tls["TLS / HTTPS"]
    end

    claude & cursor & copilot & fastagent & codex & custom --> http

    http --> oauth
    oauth <--> idp
    oauth --> core

    core --> tools & resources
    tools & resources --> plugins
    plugins --> pool

    pool --> ae & ingres & zen & informix & nosql

    Security -.-> MCP

End-to-End Request Flow

When an AI agent interacts with the database, the system follows the standard sequence. The client is any MCP-compatible tool, such as Claude Desktop, Cursor, or Codex. Authentication runs against Keycloak or Auth0, and the database is whichever Actian engine the server instance is configured for:

%%{init: {'theme': 'default', 'themeVariables': {'fontSize': '28px', 'fontFamily': 'arial'}}}%%
sequenceDiagram
    actor User
    participant Client as MCP Client
    participant Transport as HTTP / SSE
    participant Auth as OAuth 2.0
    participant Server as MCP Server
    participant Plugin as DB Plugin
    participant DB as Actian Database

    User->>Client: Natural language query
    Client->>Transport: MCP request

    Transport->>Auth: Validate JWT token
    Auth-->>Transport: Token valid

    Transport->>Server: Forward request
    Server->>Server: Route to tool/resource

    opt User Impersonation enabled
        Server->>Plugin: SET SESSION AUTHORIZATION
    end

    Plugin->>DB: Execute query
    DB-->>Plugin: Query results
    Plugin-->>Server: Formatted response
    Server-->>Transport: MCP response
    Transport-->>Client: Results
    Client-->>User: Natural language answer

Key Features

  • MCP-Native Capabilities
    Exposes tools, resources, and prompts in a standard MCP format usable by any compatible client.

  • Container-Friendly Deployment
    Runs each DBMS server instance in its own container to ensure clean environment isolation.

  • OAuth 2.0 Support
    Uses OAuth 2.0 to provide secure, standards-based access for all MCP clients.

  • HTTP/HTTPS Transport
    Operates in HTTP transport mode to simplify network connectivity.

  • Read-only by Default
    Restricts AI agents to read-only operations, preventing unintended modifications to the data.

  • Controlled Write Access
    Allows INSERT, UPDATE, and DELETE when enabled, with each write gated by an OAuth scope and human approval. See Write support.

  • Schema Discovery
    Enables AI agents to review database structures and metadata before executing queries.

  • Custom Extensions
    Add custom tools, resources, and prompts in Python, served through the same endpoint as the built-in tools and subject to the same authentication and write controls. See Extensions.

MCP Server Deployment

You can deploy an MCP Server as follows:

Configure the server

Start a server instance using a configuration that targets the specific Actian DBMS.

Connect to the database

The server connects to the target DBMS using a connection pool.

Use database capabilities

The server makes database tools, resources, and prompts available through the MCP protocol.

Connect to the AI client

An MCP-compatible client uses the database capabilities to query data, inspect metadata, and run workflows.

Info

Each Actian DBMS requires its own dedicated Actian MCP Server instance, which means there is a single server, database, and MCP endpoint.

Next Steps