slop-mcp 0.1.1__tar.gz

slop_mcp-0.1.1/.gitignore

@@ -0,0 +1,17 @@
+# Local config (not shared via git)
+.slop-mcp.local.kdl
+
+# Build artifacts
+/slop-mcp
+/build/
+**/mock-mcp/mock-mcp
+
+# Test output
+*.test
+coverage.out
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo

slop_mcp-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 StandardBeagle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

slop_mcp-0.1.1/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: slop-mcp
+Version: 0.1.1
+Summary: MCP server for orchestrating multiple MCP servers with progressive tool discovery
+Project-URL: Homepage, https://github.com/standardbeagle/slop-mcp
+Project-URL: Repository, https://github.com/standardbeagle/slop-mcp
+Project-URL: Issues, https://github.com/standardbeagle/slop-mcp/issues
+Author-email: StandardBeagle <dev@standardbeagle.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,llm,mcp,model-context-protocol,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Description-Content-Type: text/markdown
+
+# slop-mcp
+
+A Model Context Protocol (MCP) server that orchestrates multiple MCP servers, providing progressive tool discovery and efficient context management.
+
+## The Problem
+
+As described in Anthropic's article [Code Execution with MCP](https://www.anthropic.com/engineering/code-execution-with-mcp), current MCP implementations face two critical challenges:
+
+1. **Context Window Overload**: When agents connect to many tools, loading all tool definitions upfront consumes excessive tokens. With thousands of connected tools, agents must process hundreds of thousands of tokens before even reading user requests.
+
+2. **Intermediate Result Duplication**: Tool outputs repeatedly flow through the model's context. Transferring large documents between services forces the same data through the model between operations, potentially doubling token consumption.
+
+The article proposes code execution within MCP as a solution—letting agents discover tools progressively and process data within the execution environment rather than shuttling everything through context.
+
+## How slop-mcp Addresses These Issues
+
+slop-mcp takes a different but complementary approach: instead of code execution, it provides an **orchestration layer** that aggregates multiple MCP servers while maintaining context efficiency.
+
+### Progressive Tool Discovery
+
+Rather than loading all tool definitions upfront, slop-mcp exposes just 5 meta-tools:
+
+| Tool | Purpose |
+|------|---------|
+| `search_tools` | Find tools across all connected MCPs by name or description |
+| `execute_tool` | Execute a specific tool on a specific MCP |
+| `run_slop` | Execute SLOP scripts with access to all MCPs |
+| `manage_mcps` | Register/unregister MCPs at runtime |
+| `auth_mcp` | Handle OAuth authentication for MCPs that require it |
+
+This means an agent connecting to slop-mcp sees **5 tool definitions** regardless of how many MCPs are connected or how many tools they expose. The agent discovers tools on-demand via `search_tools` and executes them via `execute_tool`.
+
+### Lazy Connection & Async Startup
+
+MCP servers connect asynchronously in the background:
+
+```
+Server starts → Immediately ready to serve
+                ↓ (background)
+                MCP #1 connecting...
+                MCP #2 connecting...
+                MCP #N connecting...
+```
+
+The server doesn't block waiting for all MCPs to connect. Tools become available progressively as their MCPs come online.
+
+### In-Environment Script Execution
+
+The `run_slop` tool allows executing structured scripts that can:
+- Call multiple tools across different MCPs
+- Process intermediate results without sending them back through the model
+- Chain operations efficiently
+
+This keeps large intermediate data within the execution environment, addressing the token duplication problem.
+
+### Efficient Tool Index
+
+Tools are indexed locally when MCPs connect:
+- Fuzzy search by name or description
+- Filter by MCP name
+- No network calls during search
+- Thread-safe concurrent access
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│              slop-mcp Server                        │
+│  ┌───────────────────────────────────────────────┐  │
+│  │  5 Meta-Tools (constant context cost)         │  │
+│  │  • search_tools    • execute_tool             │  │
+│  │  • run_slop        • manage_mcps              │  │
+│  │  • auth_mcp                                   │  │
+│  └───────────────────────────────────────────────┘  │
+│                          │                          │
+│         ┌────────────────┼────────────────┐         │
+│         ▼                ▼                ▼         │
+│  ┌────────────┐  ┌────────────┐  ┌────────────┐    │
+│  │  Registry  │  │ Tool Index │  │   Auth     │    │
+│  │  (async)   │  │  (local)   │  │  (OAuth)   │    │
+│  └─────┬──────┘  └────────────┘  └────────────┘    │
+└────────┼────────────────────────────────────────────┘
+         │
+    ┌────┼────┬─────────────┐
+    ▼    ▼    ▼             ▼
+┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐
+│MCP #1│ │MCP #2│ │MCP #3│ │MCP #N│
+│stdio │ │ SSE  │ │ HTTP │ │ ...  │
+└──────┘ └──────┘ └──────┘ └──────┘
+```
+
+## Configuration
+
+slop-mcp uses KDL configuration with three-tier scoping:
+
+| Scope | File | Purpose |
+|-------|------|---------|
+| User | `~/.config/slop-mcp/config.kdl` | Cross-project defaults |
+| Project | `.slop-mcp.kdl` | Git-tracked project config |
+| Local | `.slop-mcp.local.kdl` | Git-ignored secrets |
+
+Example configuration:
+
+```kdl
+mcp "filesystem" {
+    command "npx" "-y" "@anthropic/mcp-filesystem"
+    args "/path/to/allowed/dir"
+}
+
+mcp "github" {
+    transport "sse"
+    url "https://mcp.github.com/sse"
+    // OAuth handled automatically via auth_mcp tool
+}
+```
+
+Import existing configurations:
+
+```kdl
+import "claude-desktop"  // Import from Claude Desktop config
+import "claude-code"     // Import from Claude Code settings
+```
+
+## Quick Start
+
+### npm
+
+```bash
+npx @standardbeagle/slop-mcp
+```
+
+### PyPI
+
+```bash
+uvx slop-mcp
+```
+
+Or install globally:
+
+```bash
+# npm
+npm install -g @standardbeagle/slop-mcp
+
+# pip
+pip install slop-mcp
+```
+
+### From Source
+
+```bash
+go install github.com/standardbeagle/slop-mcp/cmd/slop-mcp@latest
+```
+
+## Usage
+
+### As an MCP Server (stdio)
+
+```bash
+slop-mcp serve
+```
+
+### With HTTP/SSE Transport
+
+```bash
+slop-mcp serve --transport http --port 8080
+```
+
+### Claude Desktop Configuration
+
+Add to your Claude Desktop config:
+
+```json
+{
+  "mcpServers": {
+    "slop": {
+      "command": "slop-mcp",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+## Comparison with Code Execution Approach
+
+| Aspect | Code Execution (Article) | slop-mcp |
+|--------|-------------------------|----------|
+| Tool Discovery | Filesystem exploration | `search_tools` with fuzzy matching |
+| Context Cost | Minimal (code interpreter) | Constant (5 meta-tools) |
+| Data Processing | In-sandbox code | SLOP scripts via `run_slop` |
+| Infrastructure | Secure sandbox required | Standard MCP servers |
+| Flexibility | Full code execution | Structured tool orchestration |
+
+Both approaches solve the same core problems. Code execution offers maximum flexibility but requires sandboxing infrastructure. slop-mcp provides a simpler deployment model while still achieving significant context efficiency gains.
+
+## Related Projects
+
+- [standardbeagle-tools](https://github.com/standardbeagle/standardbeagle-tools) - Claude Code plugin for slop-mcp integration
+
+## License
+
+MIT

slop_mcp-0.1.1/README.md

@@ -0,0 +1,201 @@
+# slop-mcp
+
+A Model Context Protocol (MCP) server that orchestrates multiple MCP servers, providing progressive tool discovery and efficient context management.
+
+## The Problem
+
+As described in Anthropic's article [Code Execution with MCP](https://www.anthropic.com/engineering/code-execution-with-mcp), current MCP implementations face two critical challenges:
+
+1. **Context Window Overload**: When agents connect to many tools, loading all tool definitions upfront consumes excessive tokens. With thousands of connected tools, agents must process hundreds of thousands of tokens before even reading user requests.
+
+2. **Intermediate Result Duplication**: Tool outputs repeatedly flow through the model's context. Transferring large documents between services forces the same data through the model between operations, potentially doubling token consumption.
+
+The article proposes code execution within MCP as a solution—letting agents discover tools progressively and process data within the execution environment rather than shuttling everything through context.
+
+## How slop-mcp Addresses These Issues
+
+slop-mcp takes a different but complementary approach: instead of code execution, it provides an **orchestration layer** that aggregates multiple MCP servers while maintaining context efficiency.
+
+### Progressive Tool Discovery
+
+Rather than loading all tool definitions upfront, slop-mcp exposes just 5 meta-tools:
+
+| Tool | Purpose |
+|------|---------|
+| `search_tools` | Find tools across all connected MCPs by name or description |
+| `execute_tool` | Execute a specific tool on a specific MCP |
+| `run_slop` | Execute SLOP scripts with access to all MCPs |
+| `manage_mcps` | Register/unregister MCPs at runtime |
+| `auth_mcp` | Handle OAuth authentication for MCPs that require it |
+
+This means an agent connecting to slop-mcp sees **5 tool definitions** regardless of how many MCPs are connected or how many tools they expose. The agent discovers tools on-demand via `search_tools` and executes them via `execute_tool`.
+
+### Lazy Connection & Async Startup
+
+MCP servers connect asynchronously in the background:
+
+```
+Server starts → Immediately ready to serve
+                ↓ (background)
+                MCP #1 connecting...
+                MCP #2 connecting...
+                MCP #N connecting...
+```
+
+The server doesn't block waiting for all MCPs to connect. Tools become available progressively as their MCPs come online.
+
+### In-Environment Script Execution
+
+The `run_slop` tool allows executing structured scripts that can:
+- Call multiple tools across different MCPs
+- Process intermediate results without sending them back through the model
+- Chain operations efficiently
+
+This keeps large intermediate data within the execution environment, addressing the token duplication problem.
+
+### Efficient Tool Index
+
+Tools are indexed locally when MCPs connect:
+- Fuzzy search by name or description
+- Filter by MCP name
+- No network calls during search
+- Thread-safe concurrent access
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│              slop-mcp Server                        │
+│  ┌───────────────────────────────────────────────┐  │
+│  │  5 Meta-Tools (constant context cost)         │  │
+│  │  • search_tools    • execute_tool             │  │
+│  │  • run_slop        • manage_mcps              │  │
+│  │  • auth_mcp                                   │  │
+│  └───────────────────────────────────────────────┘  │
+│                          │                          │
+│         ┌────────────────┼────────────────┐         │
+│         ▼                ▼                ▼         │
+│  ┌────────────┐  ┌────────────┐  ┌────────────┐    │
+│  │  Registry  │  │ Tool Index │  │   Auth     │    │
+│  │  (async)   │  │  (local)   │  │  (OAuth)   │    │
+│  └─────┬──────┘  └────────────┘  └────────────┘    │
+└────────┼────────────────────────────────────────────┘
+         │
+    ┌────┼────┬─────────────┐
+    ▼    ▼    ▼             ▼
+┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐
+│MCP #1│ │MCP #2│ │MCP #3│ │MCP #N│
+│stdio │ │ SSE  │ │ HTTP │ │ ...  │
+└──────┘ └──────┘ └──────┘ └──────┘
+```
+
+## Configuration
+
+slop-mcp uses KDL configuration with three-tier scoping:
+
+| Scope | File | Purpose |
+|-------|------|---------|
+| User | `~/.config/slop-mcp/config.kdl` | Cross-project defaults |
+| Project | `.slop-mcp.kdl` | Git-tracked project config |
+| Local | `.slop-mcp.local.kdl` | Git-ignored secrets |
+
+Example configuration:
+
+```kdl
+mcp "filesystem" {
+    command "npx" "-y" "@anthropic/mcp-filesystem"
+    args "/path/to/allowed/dir"
+}
+
+mcp "github" {
+    transport "sse"
+    url "https://mcp.github.com/sse"
+    // OAuth handled automatically via auth_mcp tool
+}
+```
+
+Import existing configurations:
+
+```kdl
+import "claude-desktop"  // Import from Claude Desktop config
+import "claude-code"     // Import from Claude Code settings
+```
+
+## Quick Start
+
+### npm
+
+```bash
+npx @standardbeagle/slop-mcp
+```
+
+### PyPI
+
+```bash
+uvx slop-mcp
+```
+
+Or install globally:
+
+```bash
+# npm
+npm install -g @standardbeagle/slop-mcp
+
+# pip
+pip install slop-mcp
+```
+
+### From Source
+
+```bash
+go install github.com/standardbeagle/slop-mcp/cmd/slop-mcp@latest
+```
+
+## Usage
+
+### As an MCP Server (stdio)
+
+```bash
+slop-mcp serve
+```
+
+### With HTTP/SSE Transport
+
+```bash
+slop-mcp serve --transport http --port 8080
+```
+
+### Claude Desktop Configuration
+
+Add to your Claude Desktop config:
+
+```json
+{
+  "mcpServers": {
+    "slop": {
+      "command": "slop-mcp",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+## Comparison with Code Execution Approach
+
+| Aspect | Code Execution (Article) | slop-mcp |
+|--------|-------------------------|----------|
+| Tool Discovery | Filesystem exploration | `search_tools` with fuzzy matching |
+| Context Cost | Minimal (code interpreter) | Constant (5 meta-tools) |
+| Data Processing | In-sandbox code | SLOP scripts via `run_slop` |
+| Infrastructure | Secure sandbox required | Standard MCP servers |
+| Flexibility | Full code execution | Structured tool orchestration |
+
+Both approaches solve the same core problems. Code execution offers maximum flexibility but requires sandboxing infrastructure. slop-mcp provides a simpler deployment model while still achieving significant context efficiency gains.
+
+## Related Projects
+
+- [standardbeagle-tools](https://github.com/standardbeagle/standardbeagle-tools) - Claude Code plugin for slop-mcp integration
+
+## License
+
+MIT

slop_mcp-0.1.1/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "slop-mcp"
+version = "0.1.1"
+description = "MCP server for orchestrating multiple MCP servers with progressive tool discovery"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    { name = "StandardBeagle", email = "dev@standardbeagle.com" }
+]
+keywords = ["mcp", "model-context-protocol", "ai", "llm", "tools"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "httpx>=0.24.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/standardbeagle/slop-mcp"
+Repository = "https://github.com/standardbeagle/slop-mcp"
+Issues = "https://github.com/standardbeagle/slop-mcp/issues"
+
+[project.scripts]
+slop-mcp = "slop_mcp:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/slop_mcp"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/README.md",
+    "/LICENSE",
+]

slop_mcp-0.1.1/src/slop_mcp/__init__.py

@@ -0,0 +1,103 @@
+"""slop-mcp: MCP server for orchestrating multiple MCP servers."""
+
+import os
+import platform
+import stat
+import subprocess
+import sys
+from pathlib import Path
+
+import httpx
+
+__version__ = "0.0.0"
+
+REPO = "standardbeagle/slop-mcp"
+BINARY_NAME = "slop-mcp"
+
+
+def get_platform_info() -> tuple[str, str]:
+    """Get the current platform and architecture."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "darwin":
+        goos = "darwin"
+    elif system == "linux":
+        goos = "linux"
+    elif system == "windows":
+        goos = "windows"
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}")
+
+    if machine in ("x86_64", "amd64"):
+        goarch = "amd64"
+    elif machine in ("arm64", "aarch64"):
+        goarch = "arm64"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {machine}")
+
+    return goos, goarch
+
+
+def get_binary_path() -> Path:
+    """Get the path where the binary should be stored."""
+    cache_dir = Path.home() / ".cache" / "slop-mcp"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    goos, goarch = get_platform_info()
+    ext = ".exe" if goos == "windows" else ""
+
+    return cache_dir / f"{BINARY_NAME}-{__version__}-{goos}-{goarch}{ext}"
+
+
+def get_download_url() -> str:
+    """Get the download URL for the current platform."""
+    goos, goarch = get_platform_info()
+    ext = ".exe" if goos == "windows" else ""
+
+    version = __version__
+    if not version.startswith("v"):
+        version = f"v{version}"
+
+    return f"https://github.com/{REPO}/releases/download/{version}/{BINARY_NAME}-{goos}-{goarch}{ext}"
+
+
+def download_binary(dest: Path) -> None:
+    """Download the binary for the current platform."""
+    url = get_download_url()
+
+    with httpx.Client(follow_redirects=True, timeout=60.0) as client:
+        response = client.get(url)
+        response.raise_for_status()
+
+        dest.write_bytes(response.content)
+
+        # Make executable on Unix
+        if platform.system() != "Windows":
+            dest.chmod(dest.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def ensure_binary() -> Path:
+    """Ensure the binary exists, downloading if necessary."""
+    binary_path = get_binary_path()
+
+    if not binary_path.exists():
+        download_binary(binary_path)
+
+    return binary_path
+
+
+def main() -> int:
+    """Run the slop-mcp binary with the given arguments."""
+    try:
+        binary_path = ensure_binary()
+    except Exception as e:
+        print(f"Error downloading slop-mcp binary: {e}", file=sys.stderr)
+        return 1
+
+    result = subprocess.run([str(binary_path)] + sys.argv[1:])
+    return result.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())

slop_mcp-0.1.1/src/slop_mcp/__main__.py

@@ -0,0 +1,8 @@
+"""Entry point for python -m slop_mcp."""
+
+import sys
+
+from slop_mcp import main
+
+if __name__ == "__main__":
+    sys.exit(main())