---
title: Introduction
description: A simple overview of the Actian MCP Server, its purpose, and the core concepts behind it.
---

# Actian MCP Server

The Actian [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 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.

```mermaid
%%{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:

```mermaid
%%{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

<div class="grid cards" markdown>

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

- :material-docker: **Container-Friendly Deployment**  
  Runs each DBMS server instance in its own container to ensure clean environment isolation.

- :material-shield-lock: **OAuth 2.0 Support**  
  Uses `OAuth 2.0` to provide secure, standards-based access for all MCP clients.

- :material-transit-connection-horizontal: **HTTP/HTTPS Transport**  
  Operates in `HTTP` transport mode to simplify network connectivity.

- :material-eye-lock: **Read-only by Default**  
  Restricts AI agents to read-only operations, preventing unintended modifications to the data.

- :material-database-edit: **Controlled Write Access**  
  Allows `INSERT`, `UPDATE`, and `DELETE` when enabled, with each write gated by an OAuth scope and human approval. See [Write support](../ingres/write-support.md).

- :material-database-search: **Schema Discovery**  
  Enables AI agents to review database structures and metadata before executing queries.

- :material-puzzle: **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](../ingres/extensions/index.md).

</div>

## MCP Server Deployment

You can deploy an MCP Server as follows:

<div class="steps-container" markdown>
<div class="step-item">
<h4 class="step-title">Configure the server</h4>
<p class="step-description">Start a server instance using a configuration that targets the specific Actian DBMS.</p>
</div>
<div class="step-item">
<h4 class="step-title">Connect to the database</h4>
<p class="step-description">The server connects to the target DBMS using a connection pool.</p>
</div>
<div class="step-item">
<h4 class="step-title">Use database capabilities</h4>
<p class="step-description">The server makes database tools, resources, and prompts available through the MCP protocol.</p>
</div>
<div class="step-item">
<h4 class="step-title">Connect to the AI client</h4>
<p class="step-description">An MCP-compatible client uses the database capabilities to query data, inspect metadata, and run workflows.</p>
</div>
</div>

!!! 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

<div class="grid cards" markdown>

- :material-rocket-launch: **[Get Started](../get-started/index.md)**  
  To deploy Actian MCP Server instance and connect it to an AI client, see [Getting Started with MCP Server](../get-started/index.md).
</div>