testing-scope-mcp

Testing Scope MCP

Quick Start

Use this skill for a reusable MCP workflow against a running Scope server.

Default posture:

• Start the MCP server with uv run daydream-scope --mcp
• Connect explicitly with connect_to_scope(port=...)
• If Cursor does not surface the scope MCP tools, use the direct stdio client fallback below
• Use a lightweight pipeline such as gray for the first smoke test

Standard Workflow

1. Start or identify the target Scope HTTP server and note its port.
2. Start the Scope MCP server over stdio:

UV_NO_SYNC=1 uv run daydream-scope --mcp

3. Connect MCP to the running Scope instance (replace 8022 with the actual port):

await session.call_tool("connect_to_scope", {"port": 8022})

Workspace MCP Registration

To have Cursor expose the scope MCP tools automatically, verify .mcp.json contains:

{
  "mcpServers": {
    "scope": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "daydream-scope", "--mcp"]
    }
  }
}

If the tools are still missing after reload/reconnect, use the direct stdio fallback instead of blocking on Cursor setup.

Direct Stdio MCP Fallback

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client


async def main():
    params = StdioServerParameters(
        command="uv",
        args=["run", "daydream-scope", "--mcp"],
        env=None,
    )
    async with stdio_client(params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            await session.call_tool("connect_to_scope", {"port": 8022})
            tools = await session.list_tools()
            print([tool.name for tool in tools.tools])


asyncio.run(main())

Replace 8022 with the actual Scope HTTP port. If this client can list tools, continue testing through it even if Cursor has not exposed the tool descriptors.

Smoke Test

Before testing a larger workflow, run a minimal smoke test against the gray pipeline (no model downloads required).

1. Create a test video:

ffmpeg -y -f lavfi -i "testsrc2=size=512x512:rate=8:duration=4" -pix_fmt yuv420p /tmp/scope-mcp-gray-input.mp4

2. MCP sequence:

• connect_to_scope(port=8022)
• load_pipeline(pipeline_id="gray")
• start_stream(pipeline_id="gray", input_mode="video", input_source={"enabled": true, "source_type": "video_file", "source_name": "/tmp/scope-mcp-gray-input.mp4"})
• capture_frame()
• stop_stream()

3. Verify from evidence, not just status codes:

• Pipeline loads successfully
• capture_frame returns an image path
• The captured image is actually grayscale, not merely non-empty

Key Rules

• start_stream takes pipeline_id only, not a graph
• capture_frame returns a file path — read it back for verification
• If the MCP server was started disconnected, connect_to_scope(...) must happen first
• If MCP is unavailable, fall back to the direct stdio client or the HTTP APIs below

HTTP API Fallback

When MCP tools are unavailable or the MCP server cannot be started, use these endpoints directly against the Scope HTTP server:

Troubleshooting

When something fails, isolate the boundary first:

1. MCP server startup
2. connect_to_scope
3. Tool discovery
4. Pipeline load
5. Session start
6. Frame capture

Read logs from the failing process, make the smallest viable fix, and rerun the failing step before rerunning the full workflow.