src/omega_mcp/
├── config.py         # Standardized configuration schemas, env variable parsing, and automated boot validations
├── logger.py         # Custom telemetry logging engine directing output safely to sys.stderr
├── server.py         # Central ASGI network routing gateway, tool registry, and lifespan state orchestrator
├── core/             # PROTOCOL-AGNOSTIC DATA ENGINES (Pure Python Data Types Only)
│   ├── service_alpha.py # Foundation engine logic handling connection state pools, file systems, or databases
│   └── service_beta.py  # Standalone service driver handling network adapters, utilities, or external APIs
└── tools/            # SYMMETRICAL PRESENTATION LAYERS (Maps Core Logic to Symmetrical XML)
    ├── tool_alpha.py    # Pulls lifecycle state connections from service_alpha and compiles uniform XML records
    └── tool_beta.py     # Invokes stateless service_beta sequences and converts outputs to standard XML responses

<knowledge_source type="source_type" query="target_query">
  <record id="unique_identifier" score="relevance_weight_if_applicable">
    <specific_fact>Extracted text body content payload goes here...</specific_fact>
    <parent_lineage id="parent_id">Title, Source Reference, or Provenance Metadata Group</parent_lineage>
    <semantic_entities>comma, separated, key, concept, tags</semantic_entities>
  </record>
</knowledge_source>

  ┌──────────────────────┐      ┌───────────────────────────────┐
  │   VS Code Client     │      │   External Python Agent       │
  │   (Cline / Cursor)   │      │     (Google Gen AI SDK)       │
  └──────────┬───────────┘      └───────────────┬───────────────┘
             │                                  │
             ▼ [HTTP/SSE Network Connection]    ▼ [HTTP POST JSON-RPC]
  ┌─────────────────────────────────────────────────────────────┐
  │                 OMEGA CORE INFRASTRUCTURE SERVER            │
  │                                                             │
  │  ┌───────────┐      ┌─────────────────────────────────────┐ │
  │  │ server.py │ ───> │ tools/tool_alpha.py                 │ │
  │  └─────┬─────┘      │ tools/tool_beta.py                  │ │
  │        │            │ (Symmetrical XML Payload Compilers) │ │
  │        │            └───────────────┬─────────────────────┘ │
  │        ▼ [Lifespan Injection]       │                       │
  │  ┌───────────────────┐              │                       │
  │  │  core/service_*   │◄─────────────┘                       │
  │  └─────────┬─────────┘                                      │
  └────────────┼────────────────────────────────────────────────┘
               │
               ▼ [Network Socket Drivers / API Protocols]
┌───────────────────────────────────────────────────────────────┐
│ Target Infrastructure Layers (Databases, Cloud APIs, Systems) │
└───────────────────────────────────────────────────────────────┘

docker build -t omega-mcp .

services:
  omega-mcp:
    image: omega-mcp:latest
    container_name: nexus-tools-mcp
    ports:
      - "8080:8000" # Host Port 8080 -> Container Port 8000
    environment:
      - ENV=production
      - MCP_TRANSPORT=sse
      - MCP_HOST=0.0.0.0
      - MCP_PORT=8000
      
      # Core Service Parameter Allocations
      - SERVICE_ALPHA_URL=http://your-infrastructure-target:port
      - SERVICE_BETA_CREDENTIAL=your_secure_access_token
    restart: unless-stopped

docker compose up -d

{
  "mcpServers": {
    "omega-tools-docker": {
      "url": "http://localhost:8080/sse"
    }
  }
}

import httpx
from google import genai

ai_client = genai.Client()

def call_mcp_custom_tool(query: str) -> str:
    """Consumes the containerized MCP tool via standard network transport."""
    # FastMCP exposes active tool executions via /tools/{mcp_registered_tool_name}/call
    CONTAINER_URL = "http://localhost:8080/tools/registered_tool_name/call"
    
    try:
        response = httpx.post(CONTAINER_URL, json={"arguments": {"query": query}}, timeout=30.0)
        response.raise_for_status()
        
        # Extract content payload string directly out of standard JSON-RPC schema
        return response.json()["content"][0]["text"]
    except Exception as e:
        return f"<knowledge_source type='custom_tool' status='ERROR' details='{str(e)}'/>"

# Bind directly as a native function tool to your independent agent loop
research_agent = Agent(
    name="ResearchAgent",
    model=ai_client,
    tools=[call_mcp_custom_tool],
    instruction="Execute objective analysis using the provided infrastructure tool endpoint."
)

# filepath: src/omega_mcp/core/analytics.py
class AnalyticsService:
    async def fetch_metrics(self, target_id: str) -> dict:
        # Pure database lookups, computational algorithms, or external API fetches
        return {"id": target_id, "status": "active", "metrics": [88, 92, 95]}

# filepath: src/omega_mcp/tools/analytics_search.py
from omega_mcp.core.analytics import AnalyticsService

_service = AnalyticsService()

async def execute_analytics_tool(target_id: str) -> str:
    data = await _service.fetch_metrics(target_id)
    
    # Compile the uniform symmetrical XML layout for the LLM context window
    return (
        f"<knowledge_source type='custom_analytics' query='{target_id}'>\n"
        f"  <record id='{data['id']}'>\n"
        f"    <specific_fact>Status is {data['status']} with calculated scores.</specific_fact>\n"
        f"    <parent_lineage id='cluster_node'>Internal Operational Cluster</parent_lineage>\n"
        f"    <semantic_entities>{', '.join(map(str, data['metrics']))}</semantic_entities>\n"
        f"  </record>\n"
        f"</knowledge_source>"
    )

# filepath: src/omega_mcp/server.py
from omega_mcp.tools.analytics_search import execute_analytics_tool

@mcp.tool(name="get_custom_metrics", description="Queries internal processing performance metrics.")
async def tool_custom_metrics(target_id: str) -> str:
    return await execute_analytics_tool(target_id)

docker build -t omega-mcp .
docker compose up -d --force-recreate omega-mcp