dash-langsmith 0.1.0__tar.gz

dash_langsmith-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: dash-langsmith
+Version: 0.1.0
+Summary: Automatic LangSmith tracing for Dash MCP tool calls
+Requires-Python: >=3.9
+Requires-Dist: dash>=3.0.0
+Requires-Dist: langsmith>=0.1.0

dash_langsmith-0.1.0/README.md

@@ -0,0 +1,55 @@
+# dash-langsmith
+
+Automatic [LangSmith](https://smith.langchain.com) tracing for [Dash MCP](https://dash.plotly.com/dash-mcp) tool calls.
+
+Every time an AI agent calls a tool on your Dash MCP server, a run is recorded in LangSmith — latency, inputs, outputs, and errors included. No code changes to your app required.
+
+## Install
+
+```bash
+pip install dash-langsmith
+```
+
+## Usage
+
+Set your API key and run your app normally.
+
+```bash
+export LANGSMITH_API_KEY=your-key
+export LANGSMITH_PROJECT=my-dash-app  # optional
+python app.py
+```
+
+That's it. The `dash_hooks` entry point registers the tracing middleware automatically at startup.
+
+## How it works
+
+`dash-langsmith` uses Dash's [plugin hooks](https://dash.plotly.com/dash-plugins-using-hooks) system. On startup, `hooks.setup` wraps `app.server.wsgi_app` with a lightweight WSGI middleware that intercepts POST requests to `/_mcp`. When a `tools/call` JSON-RPC message arrives, it creates a LangSmith run before dispatching to Dash and patches it with the response on the way out.
+
+Only `tools/call` requests are traced. Layout, resource, and `tools/list` requests pass through untouched.
+
+## Optional: richer traces with `@mcp_traced`
+
+For explicit per-tool control — custom names, docstrings, per-tool project routing — use the `@mcp_traced` decorator instead of `@mcp_enabled`:
+
+```python
+from dash_langsmith import mcp_traced
+
+@mcp_traced(name="get_inventory", expose_docstring=True, project_name="my-dash-app")
+def get_inventory(category: str) -> dict:
+    """Return inventory levels for a product category."""
+    ...
+```
+
+## Configuration
+
+| Environment variable  | Default    | Description                          |
+|-----------------------|------------|--------------------------------------|
+| `LANGSMITH_API_KEY`   | —          | Required                             |
+| `LANGSMITH_PROJECT`   | —          | LangSmith project (falls back to `LANGCHAIN_PROJECT`) |
+| `DASH_MCP_PATH`       | `/_mcp`    | Override if you set a custom `mcp_path` |
+
+## Requirements
+
+- Dash ≥ 4.3.0 (MCP support)
+- langsmith ≥ 0.1.0

dash_langsmith-0.1.0/dash_langsmith/__init__.py

@@ -0,0 +1,39 @@
+"""
+dash-langsmith: automatic LangSmith tracing for Dash MCP tool calls.
+
+Install this package and every MCP tools/call request to your Dash app is
+recorded as a LangSmith run — no code changes required.
+
+Configuration via environment variables:
+  LANGSMITH_API_KEY      (required)
+  LANGSMITH_PROJECT      LangSmith project name (optional, falls back to LANGCHAIN_PROJECT)
+  DASH_MCP_PATH          MCP endpoint path (default: /_mcp)
+"""
+
+import os
+
+from dash import hooks
+
+from .decorator import mcp_traced
+from .middleware import LangSmithMCPMiddleware
+
+
+@hooks.setup()
+def _install_mcp_tracing(app):
+    mcp_path = (
+        getattr(app, "mcp_path", None)
+        or os.environ.get("DASH_MCP_PATH", "/_mcp")
+    )
+    project_name = (
+        os.environ.get("LANGSMITH_PROJECT")
+        or os.environ.get("LANGCHAIN_PROJECT")
+    )
+
+    app.server.wsgi_app = LangSmithMCPMiddleware(
+        app.server.wsgi_app,
+        mcp_path=mcp_path,
+        project_name=project_name,
+    )
+
+
+__all__ = ["LangSmithMCPMiddleware", "mcp_traced"]

dash_langsmith-0.1.0/dash_langsmith/decorator.py

@@ -0,0 +1,62 @@
+"""
+@mcp_traced decorator: wraps @mcp_enabled and adds LangSmith tracing.
+
+Use this instead of @mcp_enabled when you want per-tool traces with
+structured inputs and outputs recorded in LangSmith.
+"""
+
+from typing import Optional
+
+import langsmith
+from dash.mcp import mcp_enabled as _dash_mcp_enabled
+
+
+def mcp_traced(
+    func=None,
+    *,
+    name: Optional[str] = None,
+    expose_docstring: Optional[bool] = None,
+    project_name: Optional[str] = None,
+):
+    """
+    Expose a function as a Dash MCP tool and trace every invocation to LangSmith.
+
+    Supports both bare and parameterized usage::
+
+        @mcp_traced
+        def get_sales(region: str) -> dict:
+            ...
+
+        @mcp_traced(name="sales_by_region", expose_docstring=True, project_name="my-app")
+        def get_sales(region: str) -> dict:
+            \"\"\"Return sales total for a given region.\"\"\"
+            ...
+
+    Args:
+        name: Tool name shown to AI agents. Defaults to the function name.
+        expose_docstring: Whether to include the docstring in the tool description.
+            Inherits the app-wide setting when unset.
+        project_name: LangSmith project to record runs under.
+            Falls back to the LANGCHAIN_PROJECT env var when unset.
+    """
+
+    def decorator(fn):
+        traced = langsmith.traceable(
+            name=name or fn.__name__,
+            run_type="tool",
+            project_name=project_name,
+        )(fn)
+
+        mcp_kwargs = {}
+        if name is not None:
+            mcp_kwargs["name"] = name
+        if expose_docstring is not None:
+            mcp_kwargs["expose_docstring"] = expose_docstring
+
+        if mcp_kwargs:
+            return _dash_mcp_enabled(**mcp_kwargs)(traced)
+        return _dash_mcp_enabled(traced)
+
+    if func is not None:
+        return decorator(func)
+    return decorator

dash_langsmith-0.1.0/dash_langsmith/middleware.py

@@ -0,0 +1,190 @@
+"""
+WSGI middleware that traces Dash MCP tool calls to LangSmith.
+
+Drop-in: wrap app.server.wsgi_app and every tools/call request to your
+Dash MCP endpoint is automatically recorded as a LangSmith run.
+
+Parent-run linking
+------------------
+If the MCP client injects a LangSmith run ID into the tool call's _meta
+field, the Dash run is created as a child of that run — giving you a full
+trace from LLM decision → Dash tool → result in one LangSmith tree.
+
+On the agent side (e.g. langchain-mcp-adapters), emit:
+
+    {"method": "tools/call", "params": {
+        "name": "...", "arguments": {...},
+        "_meta": {"langsmith_run_id": "<parent-run-uuid>"}
+    }}
+
+Session tagging
+---------------
+The MCP initialize handshake is intercepted to extract the client name
+and version. All subsequent tool-call runs from that session are tagged
+with the client info.
+"""
+
+import io
+import json
+import uuid
+from datetime import datetime, timezone
+from typing import Optional
+
+import langsmith
+
+
+class LangSmithMCPMiddleware:
+    """
+    WSGI middleware that intercepts Dash MCP tool calls and traces them to LangSmith.
+
+    Automatically installed via the dash_hooks entry point when dash-langsmith
+    is installed. Can also be applied manually::
+
+        app.server.wsgi_app = LangSmithMCPMiddleware(
+            app.server.wsgi_app,
+            project_name="my-dash-app",
+        )
+    """
+
+    def __init__(
+        self,
+        app,
+        mcp_path: str = "/_mcp",
+        project_name: Optional[str] = None,
+    ):
+        self.app = app
+        self.mcp_path = mcp_path
+        self.project_name = project_name
+        self.client = langsmith.Client()
+        # session_id -> {"client_name": str, "client_version": str}
+        self._sessions: dict[str, dict] = {}
+
+    def __call__(self, environ, start_response):
+        path = environ.get("PATH_INFO", "")
+        method = environ.get("REQUEST_METHOD", "")
+
+        if not (path.endswith(self.mcp_path) and method == "POST"):
+            return self.app(environ, start_response)
+
+        try:
+            content_length = int(environ.get("CONTENT_LENGTH") or 0)
+        except (ValueError, TypeError):
+            content_length = 0
+
+        body = environ["wsgi.input"].read(content_length)
+        environ["wsgi.input"] = io.BytesIO(body)
+
+        try:
+            rpc = json.loads(body)
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            return self.app(environ, start_response)
+
+        rpc_method = rpc.get("method")
+
+        # Intercept initialize to capture client identity for session tagging.
+        if rpc_method == "initialize":
+            self._handle_initialize(environ, rpc)
+            return self.app(environ, start_response)
+
+        if rpc_method != "tools/call":
+            return self.app(environ, start_response)
+
+        return self._trace_tool_call(environ, start_response, rpc)
+
+    # ------------------------------------------------------------------
+
+    def _handle_initialize(self, environ, rpc: dict) -> None:
+        session_id = self._session_id(environ)
+        client_info = rpc.get("params", {}).get("clientInfo", {})
+        self._sessions[session_id] = {
+            "client_name": client_info.get("name", "unknown"),
+            "client_version": client_info.get("version", ""),
+        }
+
+    def _trace_tool_call(self, environ, start_response, rpc: dict):
+        params = rpc.get("params", {})
+        tool_name = params.get("name", "unknown_tool")
+        arguments = params.get("arguments", {})
+        meta = params.get("_meta", {})
+
+        # Link to a parent LangSmith run if the agent provided one.
+        parent_run_id: Optional[str] = meta.get("langsmith_run_id")
+
+        # Tag with the MCP client identity captured at initialize.
+        session_id = self._session_id(environ)
+        session = self._sessions.get(session_id, {})
+        tags = ["dash-mcp"]
+        if session.get("client_name"):
+            tags.append(f"mcp-client:{session['client_name']}")
+
+        extra = {"metadata": {"mcp_session_id": session_id, **session}}
+        if meta:
+            extra["metadata"]["mcp_meta"] = meta
+
+        run_id = str(uuid.uuid4())
+        start_time = datetime.now(timezone.utc)
+
+        self.client.create_run(
+            id=run_id,
+            name=tool_name,
+            run_type="tool",
+            inputs={"arguments": arguments},
+            project_name=self.project_name,
+            parent_run_id=parent_run_id,
+            start_time=start_time,
+            tags=tags,
+            extra=extra,
+        )
+
+        response_chunks = []
+        response_meta: dict = {}
+
+        def capturing_start_response(status, headers, exc_info=None):
+            response_meta["status"] = status
+            return start_response(status, headers, exc_info)
+
+        iterable = self.app(environ, capturing_start_response)
+
+        try:
+            for chunk in iterable:
+                response_chunks.append(chunk)
+        except Exception as exc:
+            self.client.update_run(
+                run_id,
+                error=str(exc),
+                end_time=datetime.now(timezone.utc),
+            )
+            raise
+        finally:
+            if hasattr(iterable, "close"):
+                iterable.close()
+
+        full_body = b"".join(response_chunks)
+        end_time = datetime.now(timezone.utc)
+
+        outputs: dict = {}
+        error: Optional[str] = None
+
+        try:
+            resp_json = json.loads(full_body)
+            if "result" in resp_json:
+                outputs = {"result": resp_json["result"]}
+            elif "error" in resp_json:
+                error = json.dumps(resp_json["error"])
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            outputs = {"raw": full_body.decode("utf-8", errors="replace")}
+
+        self.client.update_run(
+            run_id,
+            outputs=outputs,
+            error=error,
+            end_time=end_time,
+        )
+
+        return [full_body]
+
+    @staticmethod
+    def _session_id(environ: dict) -> str:
+        # MCP HTTP transport uses mcp-session-id header per the spec.
+        key = "HTTP_MCP_SESSION_ID"
+        return environ.get(key) or "no-session"

dash_langsmith-0.1.0/dash_langsmith.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: dash-langsmith
+Version: 0.1.0
+Summary: Automatic LangSmith tracing for Dash MCP tool calls
+Requires-Python: >=3.9
+Requires-Dist: dash>=3.0.0
+Requires-Dist: langsmith>=0.1.0

dash_langsmith-0.1.0/dash_langsmith.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+dash_langsmith/__init__.py
+dash_langsmith/decorator.py
+dash_langsmith/middleware.py
+dash_langsmith.egg-info/PKG-INFO
+dash_langsmith.egg-info/SOURCES.txt
+dash_langsmith.egg-info/dependency_links.txt
+dash_langsmith.egg-info/entry_points.txt
+dash_langsmith.egg-info/requires.txt
+dash_langsmith.egg-info/top_level.txt

dash_langsmith-0.1.0/dash_langsmith.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dash_langsmith-0.1.0/dash_langsmith.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[dash_hooks]
+dash_langsmith = dash_langsmith

dash_langsmith-0.1.0/dash_langsmith.egg-info/requires.txt

@@ -0,0 +1,2 @@
+dash>=3.0.0
+langsmith>=0.1.0

dash_langsmith-0.1.0/dash_langsmith.egg-info/top_level.txt

@@ -0,0 +1 @@
+dash_langsmith

dash_langsmith-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dash-langsmith"
+version = "0.1.0"
+description = "Automatic LangSmith tracing for Dash MCP tool calls"
+requires-python = ">=3.9"
+dependencies = [
+    "dash>=3.0.0",
+    "langsmith>=0.1.0",
+]
+
+[project.entry-points."dash_hooks"]
+dash_langsmith = "dash_langsmith"
+
+[tool.setuptools]
+packages = ["dash_langsmith"]

dash_langsmith-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+