MCP Servers

Authentication

Every request carries your API key in an Authorization: Bearer header. The key is verified server-side on each call and determines which tools your subscription tier can reach. Generate and revoke keys from Account → API Keys; the raw key is shown once, at creation.

Anyone holding the key can use your account. Revoke it there if it leaks.

decompose_goal

Decompose a natural-language goal into a structured subtask tree.

Returns: Structured subtask tree as formatted string

decompose_goal(goal="Build a REST API for user management")

{
  "goal": "Build a REST API for user management",
  "subtasks": [
    "Design database schema for users table",
    "Implement CRUD endpoints (GET/POST/PUT/DELETE)",
    "Add JWT authentication middleware",
    "Write integration tests for all endpoints"
  ],
  "ok": true
}

run_bayesian

Run Bayesian inference on a dataset.

Returns: Posterior inference results

run_bayesian(data="[2.1, 3.4, 2.8, 3.1, 2.9]", model_type="gaussian")

Model: gaussian
Posterior mean: 2.86, std: 0.21
95% CI: [2.45, 3.27]
Samples: 5

run_automl

Automated machine learning: model selection and scoring.

Returns: Best model configuration and scores

recommend_algo

Recommend the best algorithms for a given feature matrix and task.

Returns: Ranked algorithm recommendations

system_status

Return system health, component count, and uptime.

No parameters. Returns: System health, component count, uptime

list_components

List all discovered components with metadata.

No parameters. Returns: All discovered components with metadata

invoke_component

Invoke an arbitrary component operation by name.

Returns: Operation result as string

invoke_component(component="grounding", op="infer",
    params_json='{"query": "What is backpropagation?", "domain": "ai_ml"}')

{"answer": "Backpropagation is an algorithm for training neural networks...", "confidence": 0.87, "domain": "ai_ml"}

run_pipeline

Execute a multi-step component pipeline.

Returns: Pipeline execution results

run_pipeline(steps_json='[
  {"component": "ctx_search", "operation": "infer", "params": {"query": "neural networks"}},
  {"component": "ctx_rag", "operation": "infer", "params": {"query": "summarize"}}
]')

{
  "ok": true,
  "results": [
    {"step": 1, "component": "ctx_search", "status": "ok"},
    {"step": 2, "component": "ctx_rag", "status": "ok"}
  ]
}

list_programs

List all evolved programs in the EvoSkill library.

Returns: List of evolved programs with metadata

get_frontier

Get the current Pareto frontier of evolved programs.

Returns: Pareto-optimal programs with fitness scores

nav_discover

Search for components matching a query with relevance scoring.

Returns: Matching components with relevance scores

nav_discover(query="machine learning", limit=3)

[
  {"name": "adapt_sklearn", "score": 0.95, "cluster": "self_learning"},
  {"name": "adapt_pygad", "score": 0.82, "cluster": "self_learning"},
  {"name": "ctx_rag", "score": 0.78, "cluster": "symbolic_ml"}
]

nav_search

Filtered search across components by cluster or name.

Returns: Filtered search results

nav_recommend

Get ranked component recommendations for a task.

Returns: Ranked component recommendations

nav_inspect

Inspect a component's capabilities, MCP tools, and metadata.

Returns: Component capabilities, MCP tools, and metadata

nav_stats

Aggregate statistics across all components.

No parameters. Returns: Aggregate statistics across all components

nav_health

Health status for all navigator components.

No parameters. Returns: Health status for all navigator components

guide_ask

Ask a natural-language question about G6 capabilities.

Returns: Contextual answer about G6 capabilities

guide_ask(query="How do I verify code safety in G6?")

{
  "ok": true,
  "answer": "Use run_safety_pipeline for a full audit (CSF check → available formal checks → grounding). For individual checks, invoke align_csf or formal_methods directly and inspect each proof status/artifact.",
  "related_tools": ["run_safety_pipeline", "align_csf", "formal_methods"]
}

guide_how_to

Get step-by-step instructions for a task.

Returns: Step-by-step instructions

guide_find_tool

Find the best matching tool for a described need.

Returns: Best matching tool with usage guidance

guide_plan_workflow

Generate a multi-step workflow plan for a high-level goal.

Returns: Multi-step workflow plan

guide_system_overview

Get a complete system architecture summary.

No parameters. Returns: Complete system architecture summary

run_research_pipeline

Search, RAG retrieval, and summary in one call.

Returns: Search → RAG retrieval → summary

run_research_pipeline(query="transformer attention mechanisms")

{
  "ok": true,
  "steps": [
    {"step": "search", "status": "ok", "results_found": 8},
    {"step": "rag_retrieval", "status": "ok", "chunks_retrieved": 5},
    {"step": "summary", "status": "ok"}
  ],
  "summary": "Transformer attention uses scaled dot-product attention to compute relevance between query and key vectors..."
}

run_codegen_pipeline

Plan, generate, and verify code from a specification.

Returns: Plan → generate → verify

run_data_pipeline

Ingest, profile, and analyse a dataset.

Returns: Ingest → profile → analyse

run_safety_pipeline

CSF check, verification, and grounding audit.

Returns: CSF check → verify → ground

run_knowledge_pipeline

Fetch a URL, parse its content, and index the knowledge.

Returns: Fetch → parse → index

compose_and_run

Execute a pipeline with optional resource budget enforcement.

Returns: Pipeline execution with budget enforcement

compose_and_run(
  steps_json='[{"component":"ctx_search","operation":"infer","params":{"query":"BERT"}},
               {"component":"grounding","operation":"infer","params":{"domain":"ai_ml"}}]',
  budget_json='{"max_tokens": 50000, "timeout_sec": 30}'
)

{
  "ok": true,
  "results": [{"step": 1, "status": "ok"}, {"step": 2, "status": "ok"}],
  "budget_used": {"tokens": 12340, "elapsed_sec": 4.2}
}

cross_call_tool

Invoke an operation on any component by name.

Returns: Cross-component invocation result

dependency_graph

Generate a full component dependency graph.

No parameters. Returns: Full component dependency graph as text diagram

explain_component

Get a detailed explanation of a component with usage examples.

Returns: Detailed explanation with examples

evolve_skills

Run the self-improving evolution loop on a task or dataset.

propose_skill

Analyse agent failures and propose a new skill or prompt mutation.

generate_skill

Generate skill code from a proposal produced by propose_skill.

evaluate_program

Evaluate a program variant on validation data and return its score.

list_programs

List every program variant in the evolution workspace.

get_frontier

Get the current Pareto frontier of top-performing program variants.

feedback_descent_run

Run generic feedback-descent optimisation on a task.

Research Workflow

Discover components, run a research pipeline, then extract structured findings.

# 1. Find relevant components
nav_discover(query="text analysis")

# 2. Run research pipeline
run_research_pipeline(query="transformer attention mechanisms")

# 3. Extract key findings
invoke_component(component="ctx_langextract", op="infer",
    params_json='{"text": "...", "fields": ["findings", "methods"]}')

Final result:

{"findings": ["Self-attention computes O(n²) pairwise token interactions", "Multi-head attention enables parallel subspace learning"], "methods": ["scaled dot-product", "multi-head projection"]}

Code Generation with Safety

Generate code from a spec, audit it for safety, then run available formal checks for explicitly specified properties.

# 1. Generate code from spec
run_codegen_pipeline(spec="binary search function with edge case handling")

# 2. Run safety audit
run_safety_pipeline(target="generated binary search implementation")

# 3. Run available formal checks
invoke_component(component="formal_methods", op="infer",
    params_json='{"query": "verify binary_search terminates", "backend": "propositional"}')

Final result:

{"verified": true, "property": "termination", "method": "propositional", "confidence": 1.0}

Data Analysis

Plan a workflow, run a data pipeline, then get algorithm recommendations.

# 1. Plan the workflow
guide_plan_workflow(goal="analyze customer churn dataset")

# 2. Run data pipeline
run_data_pipeline(data_json='[{"id":1,"churn":0},...]')

# 3. Get algorithm recommendations
recommend_algo(X='[[1,2],[3,4]]', task="classification")

Final result:

Top recommendation: RandomForest (score=0.92)
Runner-up: GradientBoosting (score=0.89)
Task: classification | Features: 2