deep-agentic-core-mcp 0.1.0__py3-none-any.whl

deep_agentic_core_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""Core package for the DeepAgentLabs unified MCP server."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

deep_agentic_core_mcp/adapters/__init__.py

@@ -0,0 +1 @@
+"""Integration adapters for sibling DeepAgentLabs projects."""

deep_agentic_core_mcp/adapters/agentic_chaos.py

@@ -0,0 +1,6 @@
+"""Adapter boundary for agentic-chaos integration."""
+
+
+def describe_capabilities() -> list[str]:
+    """Return the initial capability placeholders for chaos integration."""
+    return ["list_faults", "run_experiment"]

deep_agentic_core_mcp/adapters/agenticlens.py

@@ -0,0 +1,6 @@
+"""Adapter boundary for agenticlens integration."""
+
+
+def describe_capabilities() -> list[str]:
+    """Return the initial capability placeholders for lens integration."""
+    return ["analyze_workflow", "profile_workflow"]

deep_agentic_core_mcp/config.py

@@ -0,0 +1,5 @@
+"""Shared project constants and metadata."""
+
+SERVER_NAME = "io.github.deepagentlabs/deep-agentic-core-mcp"
+PACKAGE_NAME = "deep-agentic-core-mcp"
+VERSION = "0.1.0"

deep_agentic_core_mcp/prompts/__init__.py

@@ -0,0 +1 @@
+"""Prompt definitions exposed by the MCP server."""

deep_agentic_core_mcp/prompts/registry.py

@@ -0,0 +1,15 @@
+"""Reusable prompt catalog placeholders."""
+
+
+def list_prompts() -> list[dict[str, str]]:
+    """Return the initial prompt registry."""
+    return [
+        {
+            "name": "lens.workflow_summary",
+            "description": "Summarize an analyzed workflow for a human operator.",
+        },
+        {
+            "name": "chaos.experiment_brief",
+            "description": "Explain the intent and expected impact of a chaos run.",
+        },
+    ]

deep_agentic_core_mcp/resources/__init__.py

@@ -0,0 +1 @@
+"""Resource catalogs exposed by the MCP server."""

deep_agentic_core_mcp/resources/catalog.py

@@ -0,0 +1,17 @@
+"""Placeholder resource catalog."""
+
+
+def list_resources() -> list[dict[str, str]]:
+    """Return the initial resource inventory."""
+    return [
+        {
+            "uri": "resource://examples/sample_workflow",
+            "name": "Sample workflow artifact",
+            "kind": "workflow-json",
+        },
+        {
+            "uri": "resource://catalogs/chaos_faults",
+            "name": "Chaos fault catalog",
+            "kind": "reference",
+        },
+    ]

deep_agentic_core_mcp/schemas/__init__.py

@@ -0,0 +1 @@
+"""Typed contracts for MCP-facing operations."""

deep_agentic_core_mcp/schemas/tooling.py

@@ -0,0 +1,26 @@
+"""Core schema definitions for early tool contracts."""
+
+from pydantic import BaseModel, Field
+
+
+class ToolDescriptor(BaseModel):
+    """Basic metadata describing an MCP tool."""
+
+    name: str
+    title: str
+    description: str
+
+
+class ResourceDescriptor(BaseModel):
+    """Basic metadata describing an MCP resource."""
+
+    uri: str
+    name: str
+    kind: str = Field(description="Broad classification for the resource payload.")
+
+
+class PromptDescriptor(BaseModel):
+    """Basic metadata describing an MCP prompt."""
+
+    name: str
+    description: str

deep_agentic_core_mcp/server.py

@@ -0,0 +1,117 @@
+"""MCP server entrypoint using the official MCP Python SDK (stdio transport)."""
+
+import asyncio
+import json
+from collections.abc import Callable
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Resource, TextContent, Tool
+from pydantic import AnyUrl
+
+from deep_agentic_core_mcp.config import SERVER_NAME
+from deep_agentic_core_mcp.resources.catalog import list_resources as _catalog_resources
+from deep_agentic_core_mcp.tools.core import health, version
+from deep_agentic_core_mcp.tools.registry import list_tools as _registry_tools
+
+# ---------------------------------------------------------------------------
+# Server instance
+# ---------------------------------------------------------------------------
+
+server = Server(SERVER_NAME)
+
+# ---------------------------------------------------------------------------
+# Tool dispatch
+# ---------------------------------------------------------------------------
+
+_TOOL_DISPATCH: dict[str, Callable[[], dict[str, str]]] = {
+    "core.health": health,
+    "core.version": version,
+}
+
+# ---------------------------------------------------------------------------
+# Tool definitions (derived from the canonical registry)
+# ---------------------------------------------------------------------------
+
+
+def _build_tools() -> list[Tool]:
+    """Build Tool objects from the central tool registry.
+
+    Only tools with a registered handler are advertised.
+    """
+    return [
+        Tool(
+            name=entry["name"],
+            description=entry["description"],
+            inputSchema={"type": "object", "properties": {}, "additionalProperties": False},
+        )
+        for entry in _registry_tools()
+        if entry["name"] in _TOOL_DISPATCH
+    ]
+
+
+def _build_resources() -> list[Resource]:
+    """Build Resource objects from the central resource catalog."""
+    return [
+        Resource(
+            uri=AnyUrl(entry["uri"]),
+            name=entry["name"],
+            mimeType="application/json",
+        )
+        for entry in _catalog_resources()
+    ]
+
+
+TOOLS: list[Tool] = _build_tools()
+RESOURCES: list[Resource] = _build_resources()
+
+# ---------------------------------------------------------------------------
+# Handlers
+# ---------------------------------------------------------------------------
+
+
+@server.list_tools()  # type: ignore[no-untyped-call, untyped-decorator]
+async def handle_list_tools() -> list[Tool]:
+    """Advertise available tools."""
+    return TOOLS
+
+
+@server.call_tool()  # type: ignore[untyped-decorator]
+async def handle_call_tool(name: str, arguments: dict[str, Any] | None) -> list[TextContent]:
+    """Dispatch tool calls and return JSON results."""
+    handler = _TOOL_DISPATCH.get(name)
+    if handler is None:
+        return [TextContent(type="text", text=json.dumps({"error": f"Unknown tool: {name}"}))]
+    result = handler()
+    return [TextContent(type="text", text=json.dumps(result))]
+
+
+@server.list_resources()  # type: ignore[no-untyped-call, untyped-decorator]
+async def handle_list_resources() -> list[Resource]:
+    """Advertise available resources."""
+    return RESOURCES
+
+
+# ---------------------------------------------------------------------------
+# Entrypoint
+# ---------------------------------------------------------------------------
+
+
+async def run_server() -> None:
+    """Start the MCP server over stdio."""
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options(),
+        )
+
+
+def main() -> None:
+    """Synchronous entrypoint for console_scripts."""
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()

deep_agentic_core_mcp/services/__init__.py

@@ -0,0 +1 @@
+"""Shared orchestration services."""

deep_agentic_core_mcp/services/registry.py

@@ -0,0 +1,25 @@
+"""Service helpers for server-side registries."""
+
+from deep_agentic_core_mcp.prompts.registry import list_prompts
+from deep_agentic_core_mcp.resources.catalog import list_resources
+from deep_agentic_core_mcp.schemas.tooling import (
+    PromptDescriptor,
+    ResourceDescriptor,
+    ToolDescriptor,
+)
+from deep_agentic_core_mcp.tools.registry import list_tools
+
+
+def tool_descriptors() -> list[ToolDescriptor]:
+    """Return typed tool metadata."""
+    return [ToolDescriptor(**tool) for tool in list_tools()]
+
+
+def resource_descriptors() -> list[ResourceDescriptor]:
+    """Return typed resource metadata."""
+    return [ResourceDescriptor(**resource) for resource in list_resources()]
+
+
+def prompt_descriptors() -> list[PromptDescriptor]:
+    """Return typed prompt metadata."""
+    return [PromptDescriptor(**prompt) for prompt in list_prompts()]

deep_agentic_core_mcp/tools/__init__.py

@@ -0,0 +1 @@
+"""Tool group modules for the MCP server."""

deep_agentic_core_mcp/tools/chaos.py

@@ -0,0 +1,8 @@
+"""Chaos tool placeholders."""
+
+from deep_agentic_core_mcp.adapters.agentic_chaos import describe_capabilities
+
+
+def capabilities() -> dict[str, list[str]]:
+    """Return placeholder chaos capabilities."""
+    return {"chaos": describe_capabilities()}

deep_agentic_core_mcp/tools/core.py

@@ -0,0 +1,13 @@
+"""Core server tool stubs."""
+
+from deep_agentic_core_mcp.config import SERVER_NAME, VERSION
+
+
+def health() -> dict[str, str]:
+    """Return a basic health payload."""
+    return {"status": "ok", "server": SERVER_NAME}
+
+
+def version() -> dict[str, str]:
+    """Return the current package version."""
+    return {"version": VERSION}

deep_agentic_core_mcp/tools/lens.py

@@ -0,0 +1,8 @@
+"""Lens tool placeholders."""
+
+from deep_agentic_core_mcp.adapters.agenticlens import describe_capabilities
+
+
+def capabilities() -> dict[str, list[str]]:
+    """Return placeholder lens capabilities."""
+    return {"lens": describe_capabilities()}

deep_agentic_core_mcp/tools/registry.py

@@ -0,0 +1,27 @@
+"""Central tool metadata registry."""
+
+
+def list_tools() -> list[dict[str, str]]:
+    """Return the initial tool inventory for the server."""
+    return [
+        {
+            "name": "core.health",
+            "title": "Health Check",
+            "description": "Return the basic health status of the MCP server.",
+        },
+        {
+            "name": "core.version",
+            "title": "Server Version",
+            "description": "Return the current server package version.",
+        },
+        {
+            "name": "lens.analyze_workflow",
+            "title": "Analyze Workflow",
+            "description": "Analyze an AgenticLens-compatible workflow artifact.",
+        },
+        {
+            "name": "chaos.list_faults",
+            "title": "List Chaos Faults",
+            "description": "List the supported fault types for chaos experiments.",
+        },
+    ]

deep_agentic_core_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: deep-agentic-core-mcp
+Version: 0.1.0
+Summary: Unified MCP server for AgenticLens and Agentic Chaos workflows.
+Project-URL: Homepage, https://github.com/DeepAgentLabs/deep-agentic-core-mcp
+Project-URL: Repository, https://github.com/DeepAgentLabs/deep-agentic-core-mcp
+Project-URL: Issues, https://github.com/DeepAgentLabs/deep-agentic-core-mcp/issues
+Author: DeepAgentLabs
+License: MIT
+Keywords: agentic-ai,chaos-engineering,llm,mcp,observability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.10.0
+Requires-Dist: pydantic<3,>=2.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# deep-agentic-core-mcp
+
+`deep-agentic-core-mcp` is the shared MCP server layer for the DeepAgentLabs
+ecosystem. It is designed to expose a single MCP interface that combines:
+
+- `agenticlens` style workflow inspection, profiling, and analysis
+- `agentic-chaos` style resilience testing and fault-injection workflows
+
+The goal is one MCP server, one package, and one registry identity rather than
+separate MCP servers for each product surface.
+
+<!-- mcp-name: io.github.deepagentlabs/deep-agentic-core-mcp -->
+
+## Idea
+
+This project is the control plane between LLM hosts and the existing Python
+libraries:
+
+- `agenticlens` remains the core profiling and analysis engine
+- `agentic-chaos` remains the core chaos and resilience engine
+- `deep-agentic-core-mcp` becomes the MCP-native interface that hosts can call
+
+That means MCP clients can connect once and access both observability and chaos
+testing capabilities through one server.
+
+## What This Server Should Eventually Do
+
+Planned capability areas:
+
+- profile an agentic workflow and return structured telemetry summaries
+- analyze workflow artifacts and surface optimization recommendations
+- run controlled chaos experiments against target workflows
+- compare normal versus chaos runs
+- expose shared resources such as workflow schemas, run metadata, and saved
+  reports
+
+## Design Principles
+
+- One MCP identity: publish a single server to the MCP Registry
+- Python-first: package and publish through PyPI
+- Thin orchestration layer: reuse `agenticlens` and `agentic-chaos` instead of
+  re-implementing their logic
+- Local-first: work well as a stdio MCP server for developer workflows
+- Expandable: leave room for a later remote deployment mode if needed
+
+## Initial Scope
+
+The first milestone is foundation only:
+
+- repository structure
+- packaging metadata
+- MCP registry metadata
+- roadmap and product framing
+- minimal server entrypoint and tool layout
+
+The first working implementation can stay intentionally small while the shape of
+the tool surface stabilizes.
+
+## Proposed MCP Surface
+
+Possible first tool groups:
+
+- `lens.profile_workflow`
+- `lens.analyze_workflow`
+- `chaos.run_experiment`
+- `chaos.list_faults`
+- `core.health`
+- `core.version`
+
+These names are placeholders, but the structure matters: one server can expose
+multiple tools without needing multiple MCP packages or registry entries.
+
+## Repository Layout
+
+```text
+mcp-server/
+├── README.md
+├── ROADMAP.md
+├── pyproject.toml
+├── server.json
+├── .gitignore
+├── docs/
+│   └── architecture.md
+├── examples/
+│   └── sample_workflow.json
+├── src/
+│   └── deep_agentic_core_mcp/
+│       ├── __init__.py
+│       ├── server.py
+│       ├── config.py
+│       ├── prompts/
+│       │   ├── __init__.py
+│       │   └── registry.py
+│       ├── resources/
+│       │   ├── __init__.py
+│       │   └── catalog.py
+│       ├── schemas/
+│       │   ├── __init__.py
+│       │   └── tooling.py
+│       ├── services/
+│       │   ├── __init__.py
+│       │   └── registry.py
+│       ├── adapters/
+│       │   ├── __init__.py
+│       │   ├── agentic_chaos.py
+│       │   └── agenticlens.py
+│       └── tools/
+│           ├── __init__.py
+│           ├── registry.py
+│           ├── chaos.py
+│           ├── core.py
+│           └── lens.py
+└── tests/
+    ├── test_imports.py
+    └── test_registry.py
+```
+
+## MCP-Oriented Structure
+
+This repository should have all of the standard layers we expect for a useful
+MCP server:
+
+- `tools/` for callable MCP tools and their registration metadata
+- `resources/` for readable assets such as fault catalogs, templates, and
+  workflow examples
+- `prompts/` for reusable prompt templates exposed through the server
+- `schemas/` for typed request and response contracts
+- `services/` for shared orchestration logic that keeps tool modules thin
+- `adapters/` for integration boundaries to `agenticlens` and
+  `agentic-chaos`
+
+The implementation is still early, but the file structure now reflects that
+shape so we can add functionality without reshuffling the repo later.
+
+## Packaging and Publishing Model
+
+`deep-agentic-core-mcp` should publish in two layers:
+
+1. Publish the Python package to PyPI.
+2. Publish the MCP metadata in `server.json` to the official MCP Registry.
+
+For PyPI-based verification, the `mcp-name` marker above must match the
+`name` field in `server.json`.
+
+## Near-Term Build Order
+
+1. Lock the canonical namespace and package metadata.
+2. Implement the stdio MCP server entrypoint.
+3. Add a minimal `core.health` tool.
+4. Add the first `agenticlens` and `agentic-chaos` adapter-backed tools.
+5. Add examples and publishable packaging checks.
+
+## Notes
+
+This scaffold assumes the intended GitHub namespace is
+`io.github.deepagentlabs/deep-agentic-core-mcp`. If the final publishing
+account or org changes, update:
+
+- the `mcp-name` marker in this README
+- `server.json`
+- any repository URLs in `pyproject.toml`

deep_agentic_core_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+deep_agentic_core_mcp/__init__.py,sha256=kpcXXYGgzMI7gdqTMPnkacPOLTCXpRmtvXrk-jPOWec,111
+deep_agentic_core_mcp/config.py,sha256=mlEntkCQG3KJIeCs4OQ7hzurzvBRRli3W5STMkOzpGE,165
+deep_agentic_core_mcp/server.py,sha256=T827I8c-h8BTeCxlvy514mZK4W6ytN_Tb7sBeHY7aRo,3747
+deep_agentic_core_mcp/adapters/__init__.py,sha256=pzJVEpJRY97cc9A8ZqHKLyweZmWiUyjGYYQ_Od6nl1E,63
+deep_agentic_core_mcp/adapters/agentic_chaos.py,sha256=-QYRVqOmZeph5QPc1HkQauQajzllNO-LENk63FV2Ilc,219
+deep_agentic_core_mcp/adapters/agenticlens.py,sha256=ZlHtCQ8ErcWK1PuCCGvBrP53CPMbLui36WJErBorPKU,223
+deep_agentic_core_mcp/prompts/__init__.py,sha256=CaHxzwxGngf66dR0p94O-uDQm6B4cDj9EPzvH1qFnY8,52
+deep_agentic_core_mcp/prompts/registry.py,sha256=78ivvsakwmMIS7Gkc5AxdVNZyuQgA8kjBDwXMgw96Lk,456
+deep_agentic_core_mcp/resources/__init__.py,sha256=r6oCIhjB9q0Ugpe08hibVdZxpTkn_cvciiOZ-ONsFk0,51
+deep_agentic_core_mcp/resources/catalog.py,sha256=r7qDmjqtgzhcQ8OusE0NxUc059kvsSh0BBhL1c1VLdM,468
+deep_agentic_core_mcp/schemas/__init__.py,sha256=ZWc0vXRW6Hqlw73FszpPHIWSiimD66-rHoaktwB5Wug,49
+deep_agentic_core_mcp/schemas/tooling.py,sha256=iwYR4R1ciFki3Ecak12_64Y2Nmij2STbbXHhbQfQt38,558
+deep_agentic_core_mcp/services/__init__.py,sha256=41sjpZbjFsPkVOnEk3ZQBR_e_4f_-pKkW2RRwvVQmLw,37
+deep_agentic_core_mcp/services/registry.py,sha256=Fi6QeQCwkMv_RJM74xjSWVenTbkaoU7FLg_T_lnNDSo,851
+deep_agentic_core_mcp/tools/__init__.py,sha256=VVDIHYoMGjtZZRtj2DwRb8uEzbkD-q0G9e6Fn-FUgyk,45
+deep_agentic_core_mcp/tools/chaos.py,sha256=P_uQGt2TaFqQHg_d3h6M5hxVKRfj1750a1IE3MwzyAM,252
+deep_agentic_core_mcp/tools/core.py,sha256=HLivqsL0fUAFCwWw-1-yRo4e2bulD71NooQm19py3rE,332
+deep_agentic_core_mcp/tools/lens.py,sha256=8McsDiijYUNFL2E64vKGJifRwxxS4TAu-EyhDjuUudc,247
+deep_agentic_core_mcp/tools/registry.py,sha256=dzOy-8Tqb2I3LygqkXjTHGCKw_hLbqov1UbLDct9KCc,881
+deep_agentic_core_mcp-0.1.0.dist-info/METADATA,sha256=FdTxkwsfvyPSvGXQbd8L3rHhGO66pA76pfbOoAFxbik,6532
+deep_agentic_core_mcp-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+deep_agentic_core_mcp-0.1.0.dist-info/entry_points.txt,sha256=YrVOMH2IHqFlrD2m798XfJoOdqNDWRh_xYa8beuaC_Y,76
+deep_agentic_core_mcp-0.1.0.dist-info/RECORD,,

deep_agentic_core_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

deep_agentic_core_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deep-agentic-core-mcp = deep_agentic_core_mcp.server:main