SDK

Conduit

Production-ready MCP client with mTLS, OAuth 2.1, and semantic discovery. Drop-in replacement for standard MCP clients — swap one import line and your agent gains identity, cost tracking, and the full DataGrout tool suite.

Get started free SDK on GitHub

MCP clients weren't built for production

Standard MCP clients give you tool calls and nothing else. No identity management, no cost tracking, no discovery, no type bridging. Every team ends up building the same scaffolding — authentication wrappers, retry logic, metadata extraction, namespace management. Conduit provides all of this out of the box, in five languages, with a single import swap.

How It Works

Your Agent (Python, TS, Rust, Elixir, Ruby)

Conduit SDK

▼

Identity & Auth

mTLS certificates, OAuth 2.1 tokens, or bearer auth — managed automatically. Zero-config identity bootstrap on first run.

▼

DataGrout Gateway

Semantic discovery, tool execution, cost tracking metadata, and the full DataGrout tool suite — all through the standard MCP protocol.

Conduit wraps the MCP protocol with production concerns. Every tool call returns structured cost metadata. First-class wrappers provide idiomatic access to DataGrout tools — namespaced by domain, with language-native patterns.

Capabilities

Five Languages, Full Parity

Python, TypeScript, Rust, Elixir, and Ruby — all with the same API surface. Idiomatic patterns for each language: async/await in Python, builders in Rust, GenServers in Elixir.

Semantic Discovery

Find tools by intent, not by name. client.discover("find unpaid invoices") returns ranked tool matches with confidence scores.

Cost Tracking Metadata

Every tool response includes structured cost data — credits consumed, model used, token counts. Three-tier fallback across _meta.datagrout, _dg, and _datagrout formats.

Namespaced Tool Wrappers

First-class access to DataGrout tools via domain namespaces: client.prism, client.logic, client.warden, client.flow, client.deliverables, client.ephemerals.

Batch Operations

perform_batch sends multiple tool calls in a single request. Reduces round trips and keeps related operations atomic.

Zero-Config Identity

mTLS certificates bootstrap automatically on first connection. No API keys to manage or rotate — the SDK handles identity lifecycle.

See It In Action

# Python — semantic discovery + namespaced wrappers
from datagrout.conduit import Client

async with Client("https://gateway.datagrout.ai/servers/{uuid}/mcp") as client:
    # Find tools by intent
    tools = await client.discover(query="find unpaid invoices")

    # Namespaced DataGrout tools
    analysis = await client.warden.scan(content="user input...")
    facts    = await client.logic.remember(text="Acme Corp ARR is $2.4M")
    results  = await client.logic.query(query="What is Acme Corp's ARR?")

    # Cost tracking on every response
    meta = client.extract_meta(results)
    print(f"Credits used: {meta.credits_used}")

One import, full access. Semantic discovery finds the right tools. Namespaced wrappers give you idiomatic access. Cost metadata comes back on every call.

Use Cases

Agent Frameworks

Drop Conduit into any agent framework as the MCP client layer. Get identity, cost tracking, and the full DataGrout tool suite without changing your agent's architecture.

Multi-Language Platforms

Build your orchestrator in Rust, your agents in Python, and your admin tools in Elixir — all sharing the same Conduit API surface and tool registry.

Production Deployments

mTLS identity, automatic retry, cost tracking, and structured metadata — the production concerns that standard MCP clients leave to you.

Composes With

Conduit is the client-side companion to every DataGrout tool. Use it with Invariant for code analysis uploads, Flow for workflow orchestration, Governor for continuous cognition, and any third-party MCP server in your tool registry.