ToolFront MCP Server

ToolFront

The missing link between AI and big data

It's hard to ask AI about your data. Out-of-the-box models struggle to understand large databases, APIs, and documents, while fine-tuned models are expensive and brittle. ToolFront solves this by helping AI models discover and learn about your data on the fly, so they can quickly answer your questions.

Features

🌊 Seamless: Connect AI to all your databases, warehouses, APIs, and documents.
⚡ Instant: Get up and running in seconds with a single command.
🧩 Pluggable: Works with any LLM, agent framework, and IDE that supports MCP.
🧠 Scalable: ToolFront automatically evaluates your AI agents and helps them improve.
🔒 Secure: Your data stays local, private, and under your control.

AI needs to be accurate and stay relevant. ToolFront’s continuous evaluation & learning (CE/CL) API automatically monitors your AI agents and improves their performance over time. This feature is in beta, and we’d love your feedback!

Quickstart

ToolFront runs on your computer through an MCP server, a secure protocol to connect apps to LLMs.

Prerequisites

uv or Docker to run the MCP server (we recommend uv)
URLs of your databases and APIs - see below
API key (optional) to automatically improve your AI agents with the CE/CL API

Run inside your AI Framework or IDE

First, create an MCP config by following the instructions for your chosen framework or IDE.

IDE	Setup Instructions	Install with UV	Install with Docker
Cursor	Settings → Cursor Settings → MCP Tools (or create `.cursor/mcp.json` file)	🔗 Quick Install	🔗 Quick Install
GitHub Copilot (VSCode)	Copilot icon → Edit preferences → Copilot Chat → MCP	🔗 Quick Install	🔗 Quick Install

Then, add as many database and API URLs to the MCP configuration as you need:

{
  "toolfront": {
    "command": "uvx",
    "args": [
      "toolfront[all]",
      "postgresql://user:pass@host:port/db",
      "https://api.com/openapi.json?api_key=key",
      "...",
      "--api-key", "YOUR-API-KEY" // Optional: CE/CL API
    ]
  }
}

{
  "toolfront": {
    "command": "docker",
    "args": [
      "run",
      "-i",
      "antidmg/toolfront",
      "postgresql://user:pass@host:port/db",
      "https://api.com/openapi.json?token=my_token",
      "--api-key", "YOUR-API-KEY" // Optional: CE/CL API
    ]
  }
}

With local file access:

{
  "toolfront-docker": {
    "command": "docker",
    "args": [
      "run",
      "-i",
      "-v", "/Users/you/Documents:/app/docs",
      "antidmg/toolfront",
      "postgresql://user:pass@host:port/db",
      "file:///app/docs",
      "--api-key", "YOUR-API-KEY"
    ]
  }
}

You're all set! You can now ask your AI agents about your data.

Tip

Installation Options: By default, uvx toolfront[all] installs all package extras. For a lighter setup, you can directly install the extras you need e.g. uvx toolfront[postgres,mysql,document]. See Databases and Document Libraries for the full list of extras.

Run directly

Spin up the ToolFront MCP server with SSE or stdio using the --transport flag.

# Using uvx and SSE
uvx "toolfront[postgres]" "postgres://user:pass@host:port/db" "https://api.com/spec.json?token=my_token" --transport sse

# Using Docker and stdio
docker run -i antidmg/toolfront "postgres://user:pass@host:port/db" "https://api.com/spec.json?token=my_token" --transport stdio

# Using Docker with local file access (requires volume mount)
docker run -i -v "/path/to/local/docs:/app/docs" antidmg/toolfront "file:///app/docs" --transport stdio

To enable self-improving AI, you can provide your CE/CL API key with the --api-key "YOUR-API-KEY" flag.

Note

Docker & Local Files: When using Docker with file:// URLs, you must mount local directories as volumes. Use -v "/local/path:/container/path" and reference the container path in your file URL.

Tip

Version control: To pin specific versions of ToolFront, use "toolfront[all]==0.1.x" for UV or antidmg/toolfront:0.1.x for Docker.

Tip

Localhost databases: When connecting to localhost databases with Docker (like duckdb or postgresql://user:pass@localhost:5432/db), add --network HOST before the image name. Remote databases (cloud, external servers) work without this flag.

Data Sources

ToolFront supports databases, APIs, and document libraries:

Databases

See the table below for the list of supported databases, extras (e.g., uvx "toolfront[snowflake,databricks]") and connection URL formats.

Database	Extras	URL Format
BigQuery	`bigquery`	`bigquery://{project-id}?credentials_path={path-to-account-credentials.json}`
Databricks	`databricks`	`databricks://token:{token}@{workspace}.cloud.databricks.com/{catalog}?http_path={warehouse-path}`
DuckDB	`duckdb`	`duckdb://{path-to-database.duckdb}`
MySQL	`mysql`	`mysql://{user}:{password}@{host}:{port}/{database}`
PostgreSQL	`postgresql`, `postgres`	`postgres://{user}:{password}@{hostname}:{port}/{database-name}`
Snowflake	`snowflake`	`snowflake://{user}:{password}@{account}/{database}`
SQL Server	`mssql`, `sqlserver`	`mssql://{user}:{password}@{server}:{port}/{database}`
SQLite	`sqlite`	`sqlite://{path-to-database.sqlite}`

Don't see your database? Submit an issue or pull request, or let us know in our Discord!

Tip

Working with local data files? Add duckdb://:memory: to your config to analyze local Parquet, CSV, Excel, and JSON files.

APIs

ToolFronts supports virtually all APIs that have an OpenAPI or Swagger specification. See the table below for a list of common APIs and their specification URLs.

API	Specification URL
Wikipedia	`https://en.wikipedia.org/api/rest_v1/?spec`
GitHub	`https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json`
Stripe	`https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json`
Slack	`https://raw.githubusercontent.com/slackapi/slack-api-specs/master/web-api/slack_web_openapi_v2.json`
Discord	`https://raw.githubusercontent.com/discord/discord-api-spec/main/specs/openapi.json`

Note

Authentication: For APIs that require authentication, append your API key or token to the specification URL (e.g., https://api.com/openapi.json?token=YOUR-API-TOKEN). ToolFront will automatically detect and use the authentication parameters in the appropriate places.

Document Libraries

ToolFront can search and read documents from local file systems, enabling AI agents to work with unstructured data alongside databases and APIs.

Document Types	Extras	URL Format
PDF, Word, PowerPoint, Excel, JSON, Markdown, TXT, XML, YAML, RTF	`document`	`file:///path/to/your/documents`

Usage:

{
  "toolfront": {
    "command": "uvx", 
    "args": [
      "toolfront[all]",
      "file:///path/to/your/documents",
      "postgresql://user:pass@host:port/db"
    ]
  }
}

Tools

MCP tools are functions that AI agents can call to interact with external systems. ToolFront comes with tools for databases, APIs, and documents:

Tool	Description	Requires API Key
`discover`	List all configured databases, APIs, and document libraries	✗
`search_documents`	Search documents by name pattern or similarity	✗
`read_document`	Read document contents with smart pagination	✗
`search_endpoints`	Search API endpoints by pattern or similarity	✗
`search_tables`	Search database tables by pattern or similarity	✗
`sample_table`	Get sample rows from a database table	✗
`inspect_table`	Show structure and columns of a database table	✗
`inspect_endpoint`	Show structure and parameters of an API endpoint	✗
`query_database`	Run read-only SQL queries against databases	✗
`request_api`	Make requests to API endpoints	✗
`search_queries`	Retrieve and learn from relevant query samples	✓
`search_requests`	Retrieve and learn from relevant requests samples	✓

FAQ

ToolFront stands out with multi-database support, self-improving AI, and a local-first architecture.

Multi-database: Instead of being limited to a single database, ToolFront connects all your databases and APIs in one place.

Self-improving: ToolFront's CE/CL API monitors your AI agents and improves their performance over time

Local-first: Cloud solutions compromise your data and rack up egress fees. ToolFront keeps everything local.

The CE/CL API uses in-context learning, a novel training-free learning framework pioneered by OpenAI. By augmenting your LLM's context with relevant samples, your agents can reason by analogy over your databases and APIs to quickly arrive at the correct answer.

CE/CL requires an API key and sends your queries and request syntax to an external service. Your data and secrets always remain secure on your local system and are never transmitted.

Local execution: All database connections and queries run on machine.
No secrets exposure: Database secrets are never shared with LLMs.
Read-only operations: Only safe, read-only database queries are allowed.
No data transmission: Your database content never leaves your environment.
Secure MCP protocol: Direct communication between agents and databases without third-party storage.

Run the uv run toolfront[all] or docker run commands with your database URLs directly from the command line. ToolFront automatically tests all connections when starting and will display detailed errors if a connection fails. If you're still having trouble, double-check your database and API URLs using the examples in the Databases section above.

Support & Community

Need help with ToolFront? We're here to assist:

Discord: Join our community server for real-time help and discussions
Issues: Report bugs or request features on GitHub Issues

Contributing

See CONTRIBUTING.md for guidelines on how to contribute to ToolFront.

License

ToolFront is released under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For the full license text, see the LICENSE file in the repository.

This server cannot be installed

security - not tested

license - permissive license

quality - not tested

How are these scores calculated?

local-only server

The server can only run on the client's local machine because it depends on local resources.

Securely connects AI agents to multiple databases simultaneously while enabling collaborative learning from team query patterns, all while keeping data private by running locally.

Related MCP Servers

AgentCraft MCP Server
seyhunak
-
security
F
license
-
quality
Integrates with the AgentCraft framework to enable secure communication and data exchange between AI agents, supporting both premade and custom enterprise AI agents.
Last updated -
1
Python
MySQL MCP Server
amornpan
-
security
F
license
-
quality
Enables secure interaction with MySQL databases, allowing AI assistants to list tables, read data, and execute SQL queries through a controlled interface.
Last updated -
Python
MySQL MCP Server
LeonMelamud
-
security
F
license
-
quality
A powerful server that enables AI agents to interact with MySQL databases, execute SQL queries, and manage database content through a simple interface.
Last updated -
25
4
JavaScript
LLM Bridge MCP
sjquant
-
security
A
license
-
quality
Enables AI agents to interact with multiple LLM providers (OpenAI, Anthropic, Google, DeepSeek) through a standardized interface, making it easy to switch between models or use multiple models in the same application.
Last updated -
3
Python
MIT License

View all related MCP servers