The command-line tool uvx mci lets you:

• Connect existing MCP servers with automatic caching and easy filtering options to make your unique set of tools
• Define your custom tools in JSON or YAML using clear, reviewable MCI schema
  • API:
    • Connect your n8n, Make and other workflow builders as tools
    • Convert any REST API Docs to AI tools in minute with LLM
    • Run remote code with AWS Lambda, judge0, etc.
    • Authentification, headers, body... Full set of API features are supported
  • CLI:
    • Run server based CLI commands as tool from simple "ls" to anything else you can install with apt-get!
    • Write separated python script and convert in tool in 30 seconds!
    • Build super fast GoLang binary and run as AI tool
  • File:
    • Manage your prompts, generate reports, and provide context with ease
    • Any file becomes a template: From printing simple variables ({{ props.message }}) to blocks like if, for & foreach
    • Everything you need to create real, dynamic and usable templates
  • Text:
    • Simplest way to return dynamic or static text from tool
    • Supports full templating as File type, but defined inside .mci.json
    • Ideal for serving dynamic assets (image URLs per user, PDFs, etc)
    • As well as for generating simple messages
• Make toolset from your custom tools: easiest way to orginize, manage and share your tools!
• Everything mantioned above you can use programatically via MCI-Adapter for your language
• Or.. Instantly serve them as a unified STDIO MCP server via uvx mci run command.
• And... Create separate .mci.json files and server them as different MCP servers for different agents! Reducing token and runtime overhead by providing small, specific context files tailored per agent.

Everything simple, super flexible and still, high performant!

MCI introduces a schema-first workflow where each file describes executable tools, metadata, and connections to other MCP servers. You can run these tools directly or compose them into a dynamic MCP network - without writing a single line of server code.

• JSON Definition Format: tools, metadata, inputs, and an explicit execution section.
• Execution types: HTTP Request, CLI Command, File & Text.
• Secrets & environment interpolation using {{env.VAR_NAME}}.
• Authentication methods: API key (header), Bearer, Basic auth, OAuth2 (client credentials).
• Local validation against a schema before execution.
• Template Engine - Dynamic value substitution for environment variables and properties, as well as advanced templating directives like @if, @foreach, etc. to support complex prompting.

1. Author a small JSON file describing tools and execution instructions.
2. Adapter loads and validates JSON, exposes tool list to the agent.
3. Agent requests a tool execution.
4. Adapter executes the mapped action synchronously, substitutes env vars/secrets as well as properties of tool ({{props.username}}), then returns structured output.

{
  "schemaVersion": "1.0",
  "metadata": {
    "name": "Example MCI Tools",
    "description": "Example JSON file demonstrating various MCI execution types",
    "version": "1.0.0",
    "license": "MIT",
    "authors": [
      "MCI Development Team"
    ]
  },
  "tools": [
    {
      "name": "get_weather",
      "title": "Get Weather Information",
      "description": "Fetch current weather information for a location using HTTP GET request",
      "inputSchema": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "City name or location"
          }
        },
        "required": [
          "location"
        ]
      },
      "execution": {
        "type": "http",
        "method": "GET",
        "url": "https://api.example.com/weather",
        "params": {
          "location": "{{props.location}}",
          "units": "metric"
        },
        "headers": {
          "Accept": "application/json"
        },
        "timeout_ms": 5000
      }
    },
  ]
}

• Synchronous execution model fits many server-side languages and developer workflows.
• Secure by design: No remote or third-party servers required — JSON + local adapter reduces supply-chain attack surface.
• Fine-grained, per-agent context reduces unnecessary tooling exposure and token cost.
• Language-agnostic: any language that can make HTTP requests and run CLI commands can implement an adapter.
• Easy to build: Share MCI Schema reference and documentation of any REST API or CLI application to LLM and build your favorite toolset in minute
• Easy to share: All you need to move your toolset to another project, or share it to the world is a single JSON file.

• Static JSON cannot express arbitrary runtime logic as flexibly as full server-side plugin architectures.
• Local adapters must be implemented/maintained per language for parity.

1. Create a small tools JSON describing the actions you need.
2. Install/run the language adapter (Python adapter).
3. Point your agent or application to the adapter and invoke tools synchronously.

• Library for ease of sharing of tools
• Package manager to download/update toolsets faster

Owner: Revaz Ghambarashvili (MaestroError) [email protected]

Contributions welcome via PRs and issues. Please include schema updates, adapter implementations, and security hardening suggestions.