Connect your AI agents to PostgreSQL, MySQL, SQL Server, Oracle, MariaDB, or any REST API. OrcKAI auto-generates a fully functional Model Context Protocol server and deploys it as a Docker container — no code required.
OrcKAI generates MCP servers for the most widely used relational databases and REST APIs, giving your AI agents structured, permission-controlled access to enterprise data.
Full support for PostgreSQL 12 through 17. OrcKAI introspects your schema, discovers tables, views, and columns, then generates an MCP server with typed tool definitions for every table you expose. Ideal for analytics stacks, SaaS backends, and data warehouses. See the PostgreSQL MCP tutorial.
Connect to MySQL 5.7 or 8.x instances. OrcKAI reads your information_schema, maps column types to MCP tool parameters, and produces a server that lets AI agents query, filter, and aggregate data across your MySQL tables without writing a single SQL statement manually.
Enterprise-grade support for Microsoft SQL Server 2016 and newer, including Azure SQL. The generator handles SQL Server-specific types, schemas, and authentication modes so your AI agents can access ERP, CRM, and reporting databases through a clean MCP interface.
Oracle Database 12c and later. OrcKAI connects via Oracle Instant Client, introspects tablespaces and schemas, and generates MCP tools that respect Oracle's data types and naming conventions. Bring AI to your Oracle EBS, HCM, or custom Oracle workloads.
Drop-in support for MariaDB 10.x and 11.x. Because MariaDB shares MySQL's wire protocol, OrcKAI leverages the same schema introspection engine with MariaDB-specific optimizations for sequence types, system-versioned tables, and columnstore indexes.
Import an OpenAPI (Swagger) spec or manually define endpoints, and OrcKAI generates an MCP server that wraps each endpoint as a callable tool. Support for Bearer tokens, API keys, custom headers, and OAuth flows means your agents can talk to any HTTP service.
Generating an MCP server in OrcKAI is a four-step process that takes less than five minutes from database connection to live deployment. There is no boilerplate to write, no Docker configuration to manage, and no MCP protocol knowledge required.
First, you provide your database connection details — host, port, credentials, and the database name. OrcKAI connects securely, reads your schema metadata, and presents a list of every table and column it discovers. You choose which tables to expose and which columns within those tables should be visible to AI agents.
OrcKAI then generates a fully compliant MCP server with typed tool definitions, input validation, and query parameterization to prevent SQL injection. The server is packaged into a Docker image and deployed to your OrcKAI environment automatically. Within seconds, any agent or workflow in your organization can call the new tools.
{
"name": "postgres-erp-mcp",
"tools": [
{
"name": "query_customers",
"description": "Search customers table",
"inputSchema": {
"type": "object",
"properties": {
"name": { "type": "string" },
"region": { "type": "string" },
"limit": { "type": "integer" }
}
}
},
{
"name": "query_orders",
"description": "Search orders table",
"inputSchema": { ... }
},
{
"name": "query_products",
"description": "Search products table",
"inputSchema": { ... }
}
]
}
Giving AI access to a database does not mean giving it access to everything. OrcKAI's MCP server generator includes a granular permission system that lets you control exactly which tables and which columns within those tables are visible to AI agents.
When you connect a database, OrcKAI presents the full schema tree. You can include or exclude individual tables, and within each included table, you can hide specific columns. This means you can expose a customers table while excluding the ssn, credit_card, or password_hash columns entirely. The generated MCP server simply does not contain tools or parameters for excluded data — it is not a runtime filter that could be bypassed.
This design-time permission model ensures that sensitive data never reaches the AI model at all. Combined with organization-scoped isolation and Docker network boundaries, OrcKAI provides defense-in-depth security for enterprise data access.
Tables: ✓ customers ✓ id, name, email, region, plan ✗ ssn ✗ credit_card_number ✗ password_hash ✓ orders ✓ id, customer_id, total, status, date ✗ internal_notes ✓ products ✓ All columns included ✗ employee_salaries (entire table excluded) ✗ audit_logs (entire table excluded)
Not all data lives in a database. SaaS products, microservices, third-party integrations, and internal tools often expose their functionality through REST APIs. OrcKAI can generate MCP servers from these APIs just as easily as from databases.
You can import an OpenAPI (Swagger) specification file, and OrcKAI will parse every endpoint, parameter, and response schema to produce a set of MCP tools. Alternatively, you can manually define endpoints by specifying the URL, HTTP method, headers, authentication mechanism, and expected request/response shapes. OrcKAI supports Bearer tokens, API key headers, basic auth, and custom header injection.
Once generated, the API-backed MCP server works identically to a database-backed one. Your AI agents call tools by name, pass structured parameters, and receive typed responses. This lets you build agents that combine data from your database with actions from your APIs in a single conversation — query your CRM database, then create a ticket in Jira, all through the same MCP-powered agent.
{
"name": "jira-mcp",
"type": "api",
"baseUrl": "https://company.atlassian.net",
"auth": {
"type": "bearer",
"token": "****"
},
"endpoints": [
{
"tool": "search_issues",
"method": "GET",
"path": "/rest/api/3/search",
"params": ["jql", "maxResults"]
},
{
"tool": "create_issue",
"method": "POST",
"path": "/rest/api/3/issue",
"body": {
"project": "string",
"summary": "string",
"priority": "string"
}
}
]
}
Every MCP server OrcKAI generates is packaged as a Docker container and deployed automatically. No Dockerfile authoring, no image registry management, no networking configuration.
OrcKAI generates a production-ready Docker image for each MCP server. The image includes the MCP runtime, your schema-specific tool definitions, database drivers, and health check endpoints. Build and deployment happen in the background — you never touch a Dockerfile.
Each MCP server container runs on an isolated Docker network. It can reach your database through a configured connection string but is not exposed to the public internet. Agent-to-MCP communication uses internal networking, keeping your data plane private and auditable.
Every deployed MCP server includes a built-in health endpoint that OrcKAI polls continuously. If a container becomes unresponsive or crashes, OrcKAI detects it and surfaces the status in your dashboard. You can stop, restart, or redeploy any MCP server with a single click.