Give agents, workflows, widgets, and APIs governed access to the data they need. Connect PostgreSQL, MySQL, SQL Server, Oracle, MariaDB, REST APIs, and internal systems with table-level, column-level, and deployment controls.
Orckai connects the apps, databases, APIs, files, and internal knowledge your company runs on, giving AI experiences structured, permission-controlled business context.
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 fields never reach the AI model at all. Combined with organization-scoped isolation and Docker network boundaries, Orckai provides defense-in-depth security for business system 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.
Create a governed system connection for these sources. Orckai handles connection, schema introspection, tool generation, and Docker deployment automatically.
Full schema introspection across all data types including pgvector for AI-native vector search. Ideal for analytics, SaaS backends, and data warehouses.
Tables, views, and stored procedures with full CRUD support. Auto-maps column types to MCP tool parameters for type-safe agent interactions.
Windows and Azure SQL Database with integrated authentication support. Connect AI agents to ERP, CRM, and reporting databases through a clean MCP interface.
Enterprise Oracle databases with tablespace awareness and Oracle-specific type handling. Bring AI to Oracle EBS, HCM, and custom Oracle workloads.
MySQL-compatible with MariaDB-specific features including sequence types, system-versioned tables, and columnstore indexes.
Any REST API endpoint wrapped as MCP tools. Import OpenAPI specs or define endpoints manually with Bearer token, API key, and OAuth support.
System connections turn your databases and APIs into governed tools that AI agents can use. Here is how teams are using them in production.
Generate an MCP server for your production database and let agents query tables, run reports, and answer business questions in natural language. End users get answers without writing SQL or waiting for the data team.
"What were our top 10 customers by revenue last quarter?"
Wrap your Salesforce or HubSpot REST API as MCP tools. Agents create leads, update opportunities, and search contacts on behalf of your sales team. Your reps get an AI assistant that actually knows your pipeline data and can take action on it.
"Create a follow-up task for every deal in Stage 3 that hasn't been touched in 14 days."
Deploy MCP servers for your HR database, finance database, and project management API. A single agent queries all three, correlates data across systems, and delivers cross-functional insights that would normally require three different dashboards and a data engineer.
"Show me all employees on Project Atlas who haven't submitted timesheets this week."
Connect to legacy databases like Oracle and SQL Server that lack modern APIs. The MCP server becomes the modern interface layer. AI agents interact with decades-old data through clean, auto-generated tools without touching the legacy system's internals.
"Pull all open purchase orders from the Oracle EBS system that are older than 90 days."
Orckai MCP servers are built for production environments where security, auditability, and multi-tenant isolation are non-negotiable. Every generated server ships with enterprise controls baked in.
Table Read Write Delete ───────────────────────────────────────── customers ✓ ✓ ✗ orders ✓ ✗ ✗ products ✓ ✓ ✓ invoices ✓ ✗ ✗ employee_salaries ✗ ✗ ✗ audit_logs ✗ ✗ ✗ Column Exclusions: customers ✗ ssn, credit_card, password_hash orders ✗ internal_notes Encryption: AES-256 (credentials at rest) Isolation: Per-org Docker network Audit: Every tool call logged