Architecture

Workspace Structure

G6Solver is built on a Polylith workspace — a monorepo architecture where code is organized into composable bricks, served to your Claude Code client via MCP.

The Seven Intelligence Classes

Architecture Stack

G6Solver runs on G6’s servers. Your Claude Code client connects over the network to the hosted MCP endpoint, which orchestrates 250+ components with configurable LLM backends. Extension packages add specialized capabilities.

All components run on the hosted service, and LLM inference runs through OpenRouter. Ollama is a local-GPU backend and is not available on the hosted service — a server cannot reach a model running on your machine — so it stays a development backend until a desktop application ships.

Components (200+)

Pure Python modules with no delivery-mechanism coupling. Each component is a focused cognitive capability.

Bases

Delivery mechanisms — thin adapters that expose components via different protocols. MCP is the primary interface for Claude Code users.

Component Model

Every component is built on three primitives: AIBlock for computation, Protocol contracts for capabilities, and Result[T] for error handling.

AIBlock[Input, Output, State]

The universal building block. Every component extends this generic dataclass.

AIBlock[I, O, S]
  Fields: name: str, state: S
  Methods:
    infer(input: I) → Result[O]       # Run inference
    learn(data: list[I]) → Result[S]  # Update state
    save(path: str) → Result[str]     # Persist state
    load(path: str) → Result[str]     # Restore state
    >> (other: AIBlock) → PipelineBlock  # Compose

# Using the Bayesian inference component
from mvp.adapt_bayesian import AdaptBayesianBlock

block = AdaptBayesianBlock(name="my_estimator")
result = block.infer({
    "data": [2.1, 3.4, 2.8, 3.1, 2.9],
    "model_type": "gaussian"
})

# result.is_ok() == True
# result.value:
# "Model: gaussian | Posterior mean=2.86, std=0.21 | 95% CI: [2.45, 3.27]"

Protocol Contracts

Structural typing that declares what a component can do.

Result[T]

Railway-oriented error type. Every operation returns a Result instead of raising exceptions.

Result[T]
  .ok(value: T) → Result[T]    # Success
  .fail(error: str) → Result[T] # Failure
  .map(fn) → Result[U]          # Transform value
  .flat_map(fn) → Result[U]     # Chain operations
  .or_else(fn) → Result[T]      # Handle errors
  .is_ok() → bool            # method, not a property
  .is_fail() → bool          # method, not a property

# Success path
result = block.infer(valid_input)     # Result.ok("Model: gaussian | ...")
doubled = result.map(len)             # Result.ok(42)

# Failure path — errors short-circuit
result = block.infer(bad_input)       # Result.fail("Empty data not allowed")
doubled = result.map(len)             # Result.fail("Empty data not allowed") — map skipped
fallback = result.or_else("default")  # "default"

Pipeline Architecture

Components compose via railway-oriented programming with explicit error handling.

# Compose components with the >> operator
search = CtxSearchBlock(name="search")
grounding = GroundingBlock(name="verify")

pipeline = search >> grounding
result = pipeline.infer({"query": "What is gradient descent?"})
# Result.ok({"answer": "...", "confidence": 0.91, "sources": [...]})

# If search fails, grounding is never called (railway short-circuit)
result = pipeline.infer({"query": ""})
# Result.fail("Empty query not allowed")

PipelineStep

Declarative step definition for the execution engine.

PipelineStep
  component: str     # Component name
  operation: str     # Operation to invoke
  params: dict       # Operation parameters

Execution Functions

run_pipeline(steps: list[PipelineStep]) → Result[list]
  Sequential execution, stops on first failure.

run_parallel(steps: list[PipelineStep]) → Result[list]
  Concurrent execution via trio nursery.

ComponentRegistry

Auto-discovers all 250+ components at import time.

registry = get_registry()
registry.list_all()      → list[ComponentMeta]
registry.invoke(name, op, params) → Result

registry = get_registry()

# Invoke any component by name
result = registry.invoke("grounding", "infer", {
    "query": "What is backpropagation?",
    "domain": "ai_ml"
})

# result is returns.Result — unwrap with .unwrap() or match
# Success: {"answer": "Backpropagation is...", "confidence": 0.87}
# Failure: "Component 'xyz' not found"

Railway Data Flow

Input → [Block A] →ok→ [Block B] →ok→ [Block C] → Output
                   →fail→ Error (short-circuits)

Data Flow Patterns

Three primary integration patterns depending on delivery mechanism.

HTTP Request → FastAPI route → Block.infer(input)
  → Result.ok(output) → JSON response (200)
  → Result.fail(error) → JSON error (422/500)

Claude Code → HTTPS / SSE → hosted MCP endpoint
  → API-key authentication
  → rate limit (per key, per tier)
  → tier gate (is this tool on your plan?)
  → admin gate (privileged tools refused)
  → billing context → FastMCP @server.tool()
  → Block.infer(input) → LLM backend (OpenRouter)
  → string response back to Claude

trio.open_nursery():
  nursery.start_soon(block_a.infer, input_a)
  nursery.start_soon(block_b.infer, input_b)
  → Results collected after all complete

Security Architecture

Security architecture for G6.

Security Controls

CSF Safety Framework

Component Runtime Security

Cloud Services Security

Licensing Model

G6Solver is proprietary software, licensed rather than sold. Access is authenticated with an API key tied to your account; which tools that key can reach depends on your plan (Free, Researcher or Builder). Source code is available for audit by licensed users but is not open source. See our Terms of Service for the terms that govern your use, and License for what happens to your work when access ends.

Key Design Decisions