Allows performing web searches using DuckDuckGo's API, returning results with titles, URLs, and snippets.
Enables querying SQLite databases with SELECT statements and listing tables.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Server Toolkit show system info"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A production-ready MCP server exposing filesystem, web search, SQLite, and system tools — plug directly into Claude Desktop or any MCP-compatible client.
The Model Context Protocol is an open standard that lets AI assistants like Claude securely call external tools — giving them real-time access to your filesystem, databases, and the web without you having to paste content into the chat manually.
Related MCP server: ABSD DevOps MCP Server
Filesystem — read_file returns any text file with numbered lines; search_files
globs a directory tree. Both tools enforce a configurable ROOT_DIR so path-traversal
attacks are impossible.
Web Search — web_search queries DuckDuckGo's free JSON API. No API key, no rate
limits, async with a 10 s timeout.
SQLite — query_sqlite runs SELECT-only queries and returns typed columns + rows;
list_tables shows the schema at a glance.
System — get_system_info snapshots OS, Python version, CPU count, memory usage,
free disk, hostname, and uptime in one call.
Option 1 — pip
pip install git+https://github.com/plasmacat420/mcp-server-toolkit.git
mcp-toolkit # starts the server on stdio (Claude Desktop mode)Option 2 — Docker
docker pull ghcr.io/plasmacat420/mcp-server-toolkit:latest
docker run -it ghcr.io/plasmacat420/mcp-server-toolkit:latestOption 3 — Docker Compose (recommended for SSE / networked use)
git clone https://github.com/plasmacat420/mcp-server-toolkit
cd mcp-server-toolkit
cp .env.example .env # edit ROOT_DIR if needed
docker compose upThe SSE endpoint is then available at http://localhost:8000.
Add the following block to claude_desktop_config.json
(~/Library/Application Support/Claude/ on macOS,
%APPDATA%\Claude\ on Windows):
{
"mcpServers": {
"mcp-toolkit": {
"command": "mcp-toolkit",
"env": {
"ROOT_DIR": "/Users/you/projects"
}
}
}
}Restart Claude Desktop — the four tool categories appear automatically in every conversation.
Tool | Description | Parameters | Returns |
| Read a text file with line numbers |
|
|
| Glob-search inside a directory |
|
|
| DuckDuckGo search (no key needed) |
|
|
| Execute a SELECT query |
|
|
| List all tables in a SQLite DB |
|
|
| Host OS / resource snapshot | (none) |
|
The mcp-client binary lets you call any tool from your terminal:
# Search for Python files
mcp-client search-files . "*.py"
# {"results": [...], "count": 12}
# Read a file
mcp-client read-file src/mcp_toolkit/server.py
# {"content": " 1 | \"\"\"MCP Server Toolkit...", "lines": 34, ...}
# Web search
mcp-client web-search "python asyncio tutorial" --max-results 3
# {"results": [{"title": "...", "url": "...", "snippet": "..."}], ...}
# Query a SQLite database
mcp-client query-db examples/sample.db "SELECT name, email FROM users LIMIT 3"
# {"columns": ["name", "email"], "rows": [["Alice Johnson", "alice@..."]], ...}
# System snapshot
mcp-client system-info
# {"os": "Linux", "cpu_count": 8, "memory_gb": 15.87, ...}
# Full demo against sample.db
mcp-client demogit clone https://github.com/plasmacat420/mcp-server-toolkit
cd mcp-server-toolkit
# Install with dev extras
pip install -e ".[dev]"
# Create the sample database
python examples/create_db.py
# Run the test suite
pytest -v
# Lint + format check
ruff check .
ruff format --check .
# Auto-fix
ruff check . --fix && ruff format .
# Full demo (requires sample.db)
python examples/demo.pypytest tests/test_filesystem.py::test_read_file_success -vThe server is built on FastMCP, which handles the MCP wire protocol.
Each tool category lives in its own module under src/mcp_toolkit/tools/;
the modules export plain async functions that know nothing about MCP.
server.py creates the FastMCP instance, imports every tool function,
and registers them with mcp.tool(). Configuration is a single
pydantic-settings BaseSettings object (config.py) that reads from
environment variables or a .env file. The CLI client (client/cli.py)
imports the same async functions directly — no MCP protocol involved —
making it easy to smoke-test individual tools.
src/mcp_toolkit/
├── server.py ← FastMCP app + tool registration
├── config.py ← pydantic-settings Settings singleton
└── tools/
├── filesystem.py read_file, search_files
├── websearch.py web_search
├── database.py query_sqlite, list_tables
└── system.py get_system_infoMIT © plasmacat420
Return a snapshot of the host system's resource usage and identity.
Returns:
Dict with keys os, os_version, python_version,
cpu_count, memory_gb, memory_used_pct,
disk_free_gb, hostname, and uptime_hours, or
{"error": message} on failure.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses possible failure with an error message dict, and lists all return keys. This is transparent about behavior, though it could mention if it's a read-only operation or has no side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise: one sentence plus a list. Front-loads the purpose immediately. Every piece of information is necessary and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with zero parameters and an existing output schema, the description is complete. It covers purpose, return format, and failure mode. No additional context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters; baseline 4. Description adds value by detailing the return keys, which compensates for lack of parameters and provides useful context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description explicitly states it returns a snapshot of host system resource usage and identity, and lists the specific keys. This is a specific verb+resource combination, clearly distinguishing it from siblings like list_tables or web_search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use versus alternatives. While the purpose is clear, the description does not mention when to use this tool instead of other info-gathering tools, nor any prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all user-defined tables in a SQLite database.
| Name | Required | Description | Default |
|---|---|---|---|
| db_path | Yes | Path to the SQLite database file. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states 'list all user-defined tables,' implying a read-only operation, but does not describe failure modes, performance implications, or any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that communicates the tool's purpose without any extraneous or redundant information, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite being a simple tool with one parameter, the description omits details like return format or distinction from system tables. However, an output schema exists, reducing the need for return value documentation. The description is mostly adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters with a description for 'db_path.' The tool description adds no further meaning beyond 'Path to the SQLite database file,' so it meets the baseline without enhancement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'user-defined tables in a SQLite database,' which is specific and distinguishes this tool from siblings like query_sqlite (which queries data) and read_file (which reads file contents).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives such as query_sqlite or search_files. The description does not mention exclusions or prerequisites, leaving the agent to infer usage without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a SELECT query against a SQLite database file.
Only SELECT statements are permitted; any other statement type returns an error without touching the database.
| Name | Required | Description | Default |
|---|---|---|---|
| db_path | Yes | Path to the SQLite database file. | |
| sql | Yes | SQL SELECT statement to execute. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It clearly discloses the critical behavioral trait that only SELECT is allowed and that other statements are safely rejected without affecting the database.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences: the first states purpose, the second adds a key restriction. No wasted words, front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (two parameters, output schema present), the description covers the purpose, behavior, and constraints completely. The sibling tools provide additional context for user guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both parameters. The description adds no additional semantic meaning beyond reinforcing the SELECT restriction, which is already in the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it executes a SELECT query on a SQLite database file, using a specific verb and resource. It distinguishes itself from siblings like list_tables and read_file by specifying the query execution context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use (for SELECT queries) and when not to (any other statement returns error). It does not mention alternatives like list_tables for schema inspection, but the sibling list provides context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a text file and return its content with line numbers.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to the file. Relative paths are resolved against ROOT_DIR. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full burden. It discloses the return format (content with line numbers) but lacks details on error handling, file size limits, or encoding. The output schema exists but is not described here.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that clearly conveys the tool's purpose. It is efficient, though a bit more structure (e.g., listing key behaviors) could improve scannability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the presence of an output schema, the description covers the essential action and return format. However, it omits details on error conditions like file not found or non-text files.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the 'path' parameter. The description adds context about relative paths being resolved against ROOT_DIR, which is beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it reads a text file and returns content with line numbers. It specifies the verb 'read' and resource 'text file', distinguishing it from sibling tools like search_files or query_sqlite.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives like search_files. Usage is implied (when you need to read a specific file), but no exclusions or when-not-to-use scenarios are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for files matching a glob pattern inside a directory.
| Name | Required | Description | Default |
|---|---|---|---|
| directory | Yes | Directory to search. Relative paths are resolved against ROOT_DIR. | |
| pattern | Yes | Glob pattern (e.g. ``"*.py"``). | |
| recursive | No | When True uses ``rglob``; otherwise uses ``glob``. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must fully disclose behavior. It only states it searches for files, not whether it is read-only, if it follows symlinks, or if there are limits on results. Key traits like side effects (none expected) are not mentioned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, 11 words, directly front-loaded with the tool's purpose. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations and minimal description, critical context is missing: what the output contains (list of file paths?), behavior for large directories, and whether it is purely read-only. Output schema exists but is not described.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are well-documented. The description adds no extra detail beyond the schema descriptions, but it provides a concise summary. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool searches for files using a glob pattern within a directory. The verb 'search' and resource 'files' are specific, and it distinguishes from sibling tools like read_file (which reads a single file) and query_sqlite (database query).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implicit: use when you need to find files by pattern. However, there is no explicit guidance on when not to use it or alternatives (e.g., read_file for reading file content, or get_system_info for system details).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the web using DuckDuckGo's free API (no API key required).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query string. | |
| max_results | No | Maximum number of results to return (default 5). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description should disclose behavioral traits like rate limits, failure modes, or data sources. Only mentions API type and authentication freedom, but not enough context for full transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is compact and front-loaded. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given simple parameters and existence of output schema, description sufficiently covers essentials. No major gaps for a straightforward web search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameter descriptions. Description adds no extra insight beyond that, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states tool performs web search using DuckDuckGo API. Distinguished from siblings (e.g., search_files for local search) by focusing on internet search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Mentions no API key required, a practical setup guideline. But lacks explicit guidance on when to use vs. siblings or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0get_system_infolist_tablesquery_sqliteread_filesearch_filesweb_searchScored across 6 tools
Each tool targets a clearly distinct domain: system info, SQLite tables, SQL queries, file reading, file search, and web search. No overlap in functionality.
All tools follow a consistent verb_noun pattern in snake_case (e.g., get_system_info, list_tables, query_sqlite, read_file, search_files, web_search), making predictions easy.
6 tools is a well-scoped number for a general-purpose toolkit, covering system, database, file, and web operations without being excessive or sparse.
The toolkit lacks write operations for files (e.g., write_file) and SQL modifications (insert/update/delete), limiting its usefulness for common tasks. This is a notable gap for a general toolkit.
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
Artifact store for AI agents — read, write, and search files by path; share by rendered URL.
PDF, image, video, OCR, screenshot, SQL, QR and text tools for agents. No API key, no signup.
AI agent tools: web search, browser, 400+ LLMs, image gen, TTS, phone verify. Pay-per-use.
