Documentation

Get started with TLCPD MCP

Connect your coding agent to your codebase's structure — outlines, exact symbols, and call graphs instead of whole-file dumps — and cut agent input tokens by ~75%. Below: a two-minute quickstart, per-agent setup, and the full tool reference.

Overview

What is TLCPD MCP?

TLCPD MCP is a Model Context Protocol server that gives your AI coding agent structured access to your codebase — outlines, exact symbol bodies, call graphs, and ranked context — instead of dumping whole files into the context window.

The result: agents find the right code in fewer, sharper steps and spend ~75% fewer input tokens getting there — roughly 4x more room for actual reasoning.

Two ways to run it

- Hosted — point your agent at your workspace's MCP URL with an access token. Nothing to install; your repo is indexed in the cloud. Best for getting started.
  • Local — run the tlocpd CLI's MCP server on your machine against a checkout. Your code never leaves your laptop.


  • > Note: Both surfaces speak the identical MCP tool contract, so you can start hosted and move local (or run both) without changing how your agent calls tools.
    Get started

    Quickstart

    The fastest path to your first tool call is the hosted MCP — no install required.

    1. Get your MCP URL and token

    1. Sign in to your TLCPD dashboard.
  • Track a repository so it gets indexed.
  • Open Settings > MCP and copy your hosted MCP URL and a developer token (prefixed gv_pat_).


  • 2. Connect your agent

    Add TLCPD MCP using the URL and token above. For Claude Code:
    claude mcp add --transport http tlcpd <your-mcp-url> \
      --header "Authorization: Bearer <your-token>"

    3. Ask a question that needs the codebase

    With the server connected, ask something like *"outline the auth module"* or *"who calls charge_card?"* Your agent will call TLCPD MCP's tools instead of grepping and reading whole files.

    > Note: For Cursor, VS Code, Continue, and local setup, see Connect your coding agent below.
    Infrastructure

    MothershipDeploy Cloud OS & Runners

    MothershipDeploy is an autonomous agentic cloud operating system matching and beating Depot, Blacksmith, Namespace, and AWS.

    GitHub Actions Drop-In Runners

    Replace expensive GitHub Enterprise and AWS runners by changing a single line in your .github/workflows/*.yml:
    jobs:
      build-and-test:
        runs-on: mothership-16vcpu-amd64
        steps:
          - uses: actions/checkout@v4
          - run: cargo test

    Key Capabilities

    - Sub-30ms MicroVM Startup: Workloads launch instantly from pre-warmed memory snapshots.
  • Depot Build Parity: Multi-arch (AMD64/ARM64) container builds with zero-copy local NVMe reflink caching (FICLONE).
  • Blacksmith CI Parity: Spot-drain preemption immunity with automatic task teleportation over QUIC.
  • Over 90% Cost Savings: Run jobs at $0.01–$0.04 / hour compared to $0.30–$1.00 on AWS.
  • Storage

    DragonS3: Pure-Rust S3 & Filecoin Archival

    DragonS3 (sansos-s3) is a hardware-accelerated, pure-Rust object store with 100% Python boto3 and AWS SDK compatibility.

    Connecting with boto3

    import boto3
    s3 = boto3.client(
        's3',
        endpoint_url='https://s3.throughputlinesofcodeperday.com',
        aws_access_key_id='YOUR_KEY',
        aws_secret_access_key='YOUR_SECRET',
        region_name='us-east-1'
    )
    s3.upload_file('model.safetensors', 'my-bucket', 'model.safetensors')

    Two-Tier Intelligent Storage Engine

    - L1 Hot Tier: Sub-millisecond reads and writes directly from local NVMe using io_uring + O_DIRECT.
  • L2 Cold Tier: Objects transitioned to GLACIER or DEEP_ARCHIVE are automatically batched into CAR v2 files via sansos-car, piece-hashed via AVX-512 sansos-commp (>15 GB/s), and sealed to Filecoin storage providers ($0.0001/GB/mo) with zero middleman markup.
  • Compute

    sansos-compute: Distributed Bare-Metal Mesh

    sansos-compute is the "Filecoin for Machines" compute fabric aggregating bare-metal servers, edge boxes, and GPU workstations into an elastic, verifiable compute mesh.

    5D Hardware Attestation

    Nodes running the sansos-compute daemon register their real hardware profile:
  • CPU: Cores, NUMA nodes, and vector extensions (AVX-512, AVX2, NEON).
  • GPU: VRAM, compute shader topology (NVIDIA, AMD ROCm, Apple Metal).
  • Memory: sansos-alloc 2MB huge-page slab availability.
  • Storage: Direct NVMe IOPS and FICLONE reflink support.


  • Cryptographic Work Leases

    Workloads execute inside isolated SansOS microVMs or WASI sandboxes. Output logs and artifact hashes are cryptographically signed producing a verifiable WorkExecutionReceipt.
    Compute

    Hyperscaler Reserved Compute Brokering (AWS, GCP, Azure, DigitalOcean)

    MothershipDeploy integrates traditional hyperscalers to broker pre-paid reserved instances and committed use discounts at deep wholesale discounts.

    1. Off-Peak Reserved Instance Arbitrage

    Enterprises with 1-year or 3-year commitments frequently underutilize reserved instances on nights and weekends. MothershipDeploy brokers this idle capacity for burst compilation and batch testing at 70–85% discounts below list price.

    2. Bring Your Own Cloud (BYOC) Mode

    Enterprise customers connect their AWS, GCP, Azure, or DigitalOcean credentials. MothershipDeploy spins up ephemeral runners inside their pre-paid VPCs at $0 marginal compute fee, consuming existing committed cloud spend.
    Applications

    HumChat: $1/User Team Collaboration Tier

    HumChat provides a full Discord-style team workspace (text channels, 384kbps Opus voice, screen sharing) for $1.00 / user / month with $0 central database bills.

    Architectural Foundation

    - Client-Side CRDTs: In-memory append-only state store using sansos-alloc and DodVec with zero GC pause and sub-50µs local full-text search.
  • E2EE Group Privacy: End-to-end encrypted channels using IETF Messaging Layer Security (MLS - RFC 9420) TreeKEM ratchets and ChaCha20-Poly1305.
  • Filecoin Storage Fabric: Multi-gigabyte attachments (up to 10GB) stream directly to Filecoin/IPFS via sansos-car and sansos-commp, eliminating expensive AWS S3 egress fees.
  • Marketplace

    Marketplace Provider Guide (Attach Your Hardware or Cloud)

    Join the MothershipDeploy decentralized infrastructure mesh to earn yield on idle hardware or monetize pre-paid cloud commitments.

    How to Attach Hardware (Bare-Metal / GPU)

    1. Install the daemon:
    curl -fsSL https://throughputlinesofcodeperday.com/install.sh | sh
    2. Run hardware attestation and register:
    sansos-compute daemon --provider bare-metal --attest --wallet <your-payout-address>

    How to Attach Reserved Cloud Capacity (AWS, GCP, Azure, DigitalOcean)

    1. Open Marketplace > Providers in the dashboard.
  • Choose your cloud provider (AWS Savings Plan, GCP CUD, Azure RI, or DigitalOcean).
  • Grant an ephemeral IAM role with instance launch/terminate permissions.
  • Set your minimum rental price floor (e.g. $0.02/core-hr) or share off-peak hours (nights/weekends).
  • Get started

    Connect your coding agent

    TLCPD MCP works with any MCP-capable agent. Grab your hosted MCP URL and gv_pat_ token from Settings > MCP, then use the snippet for your tool.

    Claude Code

    Remote (hosted):
    claude mcp add --transport http tlcpd <your-mcp-url> --header "Authorization: Bearer <your-token>"
    Or commit a project-shared .mcp.json:
    {
      "mcpServers": {
        "tlcpd": {
          "type": "http",
          "url": "<your-mcp-url>",
          "headers": { "Authorization": "Bearer <your-token>" }
        }
      }
    }

    Cursor

    Add to ~/.cursor/mcp.json (global) or .cursor/mcp.json (per-project; the project file wins):
    {
      "mcpServers": {
        "tlcpd": {
          "url": "<your-mcp-url>",
          "headers": { "Authorization": "Bearer <your-token>" }
        }
      }
    }

    VS Code

    VS Code uses a top-level servers key in .vscode/mcp.json:
    {
      "servers": {
        "tlcpd": {
          "type": "http",
          "url": "<your-mcp-url>",
          "headers": { "Authorization": "Bearer <your-token>" }
        }
      }
    }

    Continue

    Add a YAML file at .continue/mcpServers/tlcpd.yaml:
    name: tlcpd
    type: streamable-http
    url: <your-mcp-url>
    requestOptions:
      headers:
        Authorization: Bearer <your-token>

    Local (any agent)

    Install the CLI, then run the MCP server against a checkout.

    macOS / Linux:
    curl -fsSL https://throughputlinesofcodeperday.com/install.sh | sh
    Windows (PowerShell):
    irm https://throughputlinesofcodeperday.com/install.ps1 | iex
    Then import a repo and start the server:
    tlocpd import .
    tlocpd mcp
    Then point your agent's launch config at it:
    {
      "mcpServers": {
        "tlcpd": { "command": "tlocpd", "args": ["mcp"] }
      }
    }
    Reference

    Tools reference

    Every tool returns high-signal structure, not raw file dumps — that is where the token savings come from.

    Navigation

    - outline — the shape of a file or directory (symbols, signatures, nesting) without bodies. Call this before reading a whole file.
  • get_symbol — the exact source of one symbol (function, type, method). Pull bodies only for what you will edit or quote.
  • search — semantic + lexical search across the repo; returns ranked locations, not whole files.
  • structural_grep — pattern search over syntax (AST-aware), not plain text.


  • Understanding change

    - callers — who calls a symbol (reverse call graph).
  • impact — what a change to a symbol could affect, transitively.
  • symbol_diff — how a symbol changed between two revisions.
  • blame_symbol — the history behind a specific symbol.
  • log_search — search commit history by content and intent.


  • Task-shaped

    - context_pack — give it a task in plain language; it returns a ranked, budgeted bundle of exactly the code the task needs. Start here for open-ended work.
    Reference

    Authentication & tokens

    Hosted access is authorized with a developer token minted in your dashboard.

    Get a token

    1. Open Settings > MCP in your TLCPD dashboard.
  • Generate a developer token — it is prefixed gv_pat_.
  • Pass it to your agent as a bearer header: Authorization: Bearer gv_pat_... (or via the GANVIL_INDEX_TOKEN environment variable for CLI-style configs).


  • Scope and safety

    - Tokens are scoped to your workspace and the repositories it tracks.
  • Treat a token like a password — anyone holding it can query your indexed code.
  • Rotate or revoke a token any time from the same Settings page.