ToolFront MCP Server: AI Agent for Securely Connecting Coding Assistant to Team Database via MCP Protocol

Toolfront

ToolFront is an AI proxy database connection tool that securely connects coding assistants to team databases through the MCP protocol, enabling collaborative learning and sharing of query patterns.

Database Developer tools #Database connection #AI collaboration #Privacy and security #Query optimization .Python

rating : 2.5 points

downloads : 5.7K

update time : 2025-07-24

Open Site

What is ToolFront?

ToolFront is a Model Context Protocol (MCP) server that connects AI assistants (such as Cursor, GitHub Copilot) to your databases. Through ToolFront, AI assistants can access database structures and historical query patterns, thereby better understanding and performing database-related tasks.

How to use ToolFront?

ToolFront runs via simple commands or configuration files and supports multiple database connection methods. You only need to provide the database URL and an optional API key to allow AI assistants to securely access database information in your environment.

Applicable scenarios

ToolFront is suitable for development environments where AI assistants need to interact with databases, such as data querying, analysis, and code generation. It is particularly suitable for scenarios where data privacy needs to be protected and team knowledge needs to be shared.

Main features

Multi-database support

Supports multiple database types, including PostgreSQL, Snowflake, MySQL, BigQuery, etc. One MCP server can manage all database connections.

Privacy protection

All database connections and queries run locally, and data will not leave your device, ensuring data security.

Team collaborative learning

AI assistants can learn from the team's historical queries, improving their understanding of database structures and query patterns.

Local execution

All operations are executed on your computer without relying on cloud services, ensuring complete control over data.

Toolset

Provides database tools such as testing, discovery, scanning, inspection, sampling, and querying to help AI assistants interact with databases more efficiently.

Advantages

Supports multiple database types, reducing the management burden of multiple MCP servers

Data is processed locally, ensuring data security and privacy

AI assistants can learn from the team's historical queries, improving work efficiency

Simple and easy to use. You can quickly start by providing the database connection string

Limitations

Requires a certain technical foundation to configure the database connection string

Does not support direct modification of database content and is limited to read-only queries

Currently does not support all complete connection parameters of all database types

How to use

Install dependencies

Install uv or Docker as the running environment for the MCP server.

Get the database connection string

Obtain the correct connection string format from the database provider, for example: 'postgresql://user:pass@host:port/db'.

Run ToolFront

Run ToolFront using uv or Docker commands and provide the database connection string and an optional API key.

Configure the IDE

Set up the MCP tool in IDEs such as Cursor and GitHub Copilot to point to the ToolFront server.

Usage examples

AI assistant queries the database

When a developer uses GitHub Copilot and asks about the structure of a certain table, the AI assistant will call the database tools provided by ToolFront to obtain information.

Team collaboration optimizes queries

After team members query the same table multiple times, the AI assistant will remember these query patterns and provide more accurate suggestions for subsequent queries.

Analyze local data files

Use DuckDB to connect to local CSV files and let the AI assistant analyze the data content and generate query suggestions.

Frequently Asked Questions

Is ToolFront secure?

How to connect to a database after an SSH tunnel?

Which databases does ToolFront support?

Is an API key required?

How to debug connection issues?

Related resources

GitHub repository

View the source code, submit issues, and contribute

Discord community

Join our community to get real-time help and discussions

Documentation guide

Learn how to configure the MCP tool in Cursor

MCP protocol specification

Learn more about the Model Context Protocol

🚀 ToolFront

AI agents often lack database context, and teams frequently rewrite the same queries due to lost past work. ToolFront connects agents to your databases and provides them with your team's proven query patterns, enabling agents and teammates to learn from each other and accelerate development.

✨ Features

⚡ One-step setup: Connect coding agents like Cursor, GitHub Copilot, and Claude to all your databases with a single command or config.
🔒 Privacy-first: Your data never leaves your premises, and is only shared between agents and databases through a secure MCP server.
🧠 Collaborative learning: The more your team uses ToolFront, the better your AI agents understand your databases and query patterns. Requires API key.

🚀 Quick Start

ToolFront runs on your computer through an MCP server, a secure protocol that lets apps provide context to LLM models.

Prerequisites

uv or Docker to run the MCP server (we recommend uv)
Database connection URLs of your databases - see below
API key (optional) to activate collaborative learning - see below

Run ToolFront in your IDE

First, create an MCP config by clicking a setup button above or navigating to the MCP settings for your IDE:

IDE	Setup Instructions	Documentation
Cursor	Settings → Cursor Settings → MCP Tools (or create `.cursor/mcp.json` file)	Cursor Documentation
GitHub Copilot (VSCode)	Copilot icon → Edit preferences → Copilot Chat → MCP	GitHub Copilot Documentation
Windsurf	Plugins icon → Plugin Store → Add manually (or edit `~/.codeium/windsurf/mcp_config.json`)	Windsurf Documentation
Claude Code	Run `claude mcp add toolfront uvx toolfront [database-urls] --api-key YOUR-API-KEY`	Claude Code Documentation

Then, edit the MCP configuration with your database connection URLs and optional API key:

Edit UV Config

{
  // Rest of config file
  "toolfront": {
    "command": "uvx",
    "args": [
      "toolfront",
      "snowflake://user:pass@org",
      "postgresql://user:pass@host:port/db",
      # Add other database URLs here
      "--api-key", "YOUR-API-KEY"  // Optional
    ]
  }
}

Edit Docker Config

{
  // Rest of config file
  "toolfront": {
    "command": "docker",
    "args": [
      "run",
      "-i",
      "antidmg/toolfront",
      "snowflake://user:pass@org",
      "postgresql://user:pass@host:port/db",
      # Add other database URLs here
      "--api-key", "YOUR-API-KEY"  // Optional
    ]
  }
}

You're all set! You can now ask your coding assistant about your databases.

💡 Usage Tip

Version control: You can pin to specific versions for consistency. Use toolfront==0.1.x for UV or antidmg/toolfront:0.1.x for Docker.

Run ToolFront from your Terminal

To use ToolFront outside your IDE, run it directly from your terminal with your database URLs and optional API key:

# Using UV
uvx toolfront "snowflake://user:pass@org" "postgresql://user:pass@host:port/db" --api-key "YOUR-API-KEY"

# Using Docker  
docker run -i antidmg/toolfront "snowflake://user:pass@org" "postgresql://user:pass@host:port/db" --api-key "YOUR-API-KEY"

💡 Usage Tip

Localhost databases: Add --network host before the image name when connecting to databases running on localhost.

🧠 Collaborative In-context Learning

Data teams keep rewriting the same queries because past work often gets siloed, scattered, or lost. ToolFront teaches AI agents how your team works with your databases through in-context learning. With ToolFront, your agents can:

Reason about historical query patterns
Remember relevant tables and schemas
Reference your and your teammates' work

⚠️ Important Note

In-context learning is currently in open beta. To request an API key, please email Esteban at esteban@kruskal.ai or hop into our Discord server.

📦 Databases

ToolFront supports the following databases:

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

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

💡 Usage Tip

SSH tunneling: For databases behind SSH bastions, add SSH parameters to your URL: postgresql://user:pass@db:5432/database?ssh_host=bastion&ssh_user=ubuntu&ssh_password=pass or use ssh_key_path=/path/to/key.pem for key authentication.

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

🛠️ Tools

MCP tools are functions that AI agents can call to interact with external systems. ToolFront comes with seven database tools:

Tool	Description	Requires API Key
`test`	Tests whether a data source connection is working	✗
`discover`	Discovers and lists all configured databases and file sources	✗
`scan`	Searches for tables using regex, fuzzy matching, or TF-IDF similarity	✗
`inspect`	Inspects table schemas, showing column names, data types, and constraints	✗
`sample`	Retrieves sample rows from tables to understand data content and format	✗
`query`	Executes read-only SQL queries against databases with error handling	✗
`learn`	Retrieves relevant queries or tables for in-context learning	✓

❓ FAQ

How is ToolFront different from other database MCPs?

ToolFront has three key advantages: multi-database support, privacy-first architecture, and collaborative learning.

Multi-database support: While some general-purpose MCP servers happen to support multiple databases, most database MCPs only work with one database at a time, forcing you to manage separate MCP servers for each connection. ToolFront connects to all your databases in one place.

Privacy-first architecture: Other multi-database solutions route your data through the cloud, which racks up egress fees and creates serious privacy, security, and access control issues. ToolFront keeps everything local.

Collaborative learning: Database MCPs just expose raw database operations. ToolFront goes further by teaching your AI agents successful query patterns from your team's work, helping them learn your specific schemas and data relationships to improve over time.

How is collaborative learning different from agent memory?

Agent memory stores conversation histories for individuals, whereas ToolFront's collaborative learning remembers relational query patterns across your team and databases.

When one teammate queries a database, that knowledge becomes available to other team members using ToolFront. The system gets smarter over time by learning from your team's collective database interactions.

What data is collected during collaborative learning?

With an API key, ToolFront only logs the query syntax and their descriptions generated by your AI agents. It never collects your actual database content or personal information. For details, see the query and learn functions in tools.py.

How does ToolFront keep my data safe?

Local execution: All database connections and queries run on your machine
No secrets exposure: Database credentials are never shared with AI agents
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 with no third-party storage

How do I troubleshoot connection issues?

Run the uvx toolfront or docker run commands with your database URLs directly from the command line. ToolFront automatically tests all connections before starting and shows detailed error messages if any connection fails.

If you're still having trouble, double-check your database 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.