foodforthought-cli 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

ate/mcp_server.py

@@ -64,6 +64,9 @@ server = Server("foodforthought")
 # Initialize ATE client
 client = ATEClient()
 
+# Active recording state for telemetry recording tools
+_active_recording = None
+
 
 # ============================================================================
 # Tool Definitions
@@ -1553,6 +1556,133 @@ def get_bridge_tools() -> List[Tool]:
     ]
 
 
+def get_recording_tools() -> List[Tool]:
+    """
+    Telemetry recording tools for the Data Flywheel.
+
+    These tools enable recording robot telemetry from edge deployments
+    and uploading to FoodforThought for labeling and training data.
+    """
+    return [
+        Tool(
+            name="ate_record_start",
+            description="Start recording telemetry from a robot. Records joint states, velocities, and sensor data for later upload to FoodforThought.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "ID of the robot to record from",
+                    },
+                    "skill_id": {
+                        "type": "string",
+                        "description": "Skill ID being executed (for lineage tracking)",
+                    },
+                    "task_description": {
+                        "type": "string",
+                        "description": "Human-readable description of what the robot is doing",
+                    },
+                },
+                "required": ["robot_id", "skill_id"],
+            },
+        ),
+        Tool(
+            name="ate_record_stop",
+            description="Stop the current recording and optionally upload to FoodforThought. Returns a summary of the recording with artifact ID if uploaded.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "success": {
+                        "type": "boolean",
+                        "description": "Whether the execution was successful (affects training data quality)",
+                        "default": True,
+                    },
+                    "notes": {
+                        "type": "string",
+                        "description": "Notes about the recording (failures, edge cases, etc.)",
+                    },
+                    "upload": {
+                        "type": "boolean",
+                        "description": "Whether to upload to FoodforThought",
+                        "default": True,
+                    },
+                    "create_labeling_task": {
+                        "type": "boolean",
+                        "description": "Create a labeling task for community annotation",
+                        "default": False,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_record_status",
+            description="Get the status of the current recording session.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="ate_record_demonstration",
+            description="Record a timed demonstration for training data. Starts recording, waits for the specified duration, then stops and uploads.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "ID of the robot to record from",
+                    },
+                    "skill_id": {
+                        "type": "string",
+                        "description": "Skill being demonstrated",
+                    },
+                    "task_description": {
+                        "type": "string",
+                        "description": "What the robot is demonstrating",
+                    },
+                    "duration_seconds": {
+                        "type": "number",
+                        "description": "How long to record (default: 30 seconds)",
+                        "default": 30.0,
+                    },
+                    "create_labeling_task": {
+                        "type": "boolean",
+                        "description": "Create a labeling task for community annotation after upload",
+                        "default": True,
+                    },
+                },
+                "required": ["robot_id", "skill_id", "task_description"],
+            },
+        ),
+        Tool(
+            name="ate_recordings_list",
+            description="List telemetry recordings uploaded to FoodforThought. Filter by robot, skill, or success status.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "Filter by robot ID",
+                    },
+                    "skill_id": {
+                        "type": "string",
+                        "description": "Filter by skill ID",
+                    },
+                    "success": {
+                        "type": "boolean",
+                        "description": "Filter by success status",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                        "default": 20,
+                    },
+                },
+            },
+        ),
+    ]
+
+
 @server.list_tools()
 async def list_tools() -> List[Tool]:
     """List all available MCP tools"""
@@ -1573,6 +1703,7 @@ async def list_tools() -> List[Tool]:
     tools.extend(get_deploy_tools())
     tools.extend(get_test_tools())
     tools.extend(get_compiler_tools())
+    tools.extend(get_recording_tools())  # Data Flywheel telemetry recording
     return tools
 
 
@@ -2385,6 +2516,262 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
             except Exception as e:
                 return [TextContent(type="text", text=f"# Validation Error\n\nFailed to parse skill specification:\n\n```\n{str(e)}\n```")]
 
+        # ============================================================================
+        # Recording Tools (Data Flywheel)
+        # ============================================================================
+
+        elif name == "ate_record_start":
+            robot_id = arguments["robot_id"]
+            skill_id = arguments["skill_id"]
+            task_description = arguments.get("task_description", "")
+
+            # Store recording state in a module-level variable
+            global _active_recording
+            import time
+            import uuid
+
+            _active_recording = {
+                "id": str(uuid.uuid4()),
+                "robot_id": robot_id,
+                "skill_id": skill_id,
+                "task_description": task_description,
+                "start_time": time.time(),
+                "frames": [],
+            }
+
+            result_text = f"# Recording Started\n\n"
+            result_text += f"**Recording ID:** {_active_recording['id']}\n"
+            result_text += f"**Robot:** {robot_id}\n"
+            result_text += f"**Skill:** {skill_id}\n"
+            if task_description:
+                result_text += f"**Task:** {task_description}\n"
+            result_text += f"\nRun `ate_record_stop` when finished to upload to FoodforThought."
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_record_stop":
+            global _active_recording
+            import time
+
+            if not _active_recording:
+                return [TextContent(type="text", text="No active recording. Start one with `ate_record_start`.")]
+
+            success = arguments.get("success", True)
+            notes = arguments.get("notes", "")
+            upload = arguments.get("upload", True)
+            create_labeling_task = arguments.get("create_labeling_task", False)
+
+            # Calculate duration
+            end_time = time.time()
+            duration = end_time - _active_recording["start_time"]
+            frame_count = len(_active_recording.get("frames", []))
+
+            recording_summary = {
+                "id": _active_recording["id"],
+                "robot_id": _active_recording["robot_id"],
+                "skill_id": _active_recording["skill_id"],
+                "task_description": _active_recording.get("task_description", ""),
+                "duration": duration,
+                "frame_count": frame_count,
+                "success": success,
+                "notes": notes,
+            }
+
+            result_text = f"# Recording Stopped\n\n"
+            result_text += f"**Recording ID:** {recording_summary['id']}\n"
+            result_text += f"**Duration:** {duration:.1f}s\n"
+            result_text += f"**Frames:** {frame_count}\n"
+            result_text += f"**Success:** {'Yes' if success else 'No'}\n"
+
+            if upload:
+                # Upload to FoodforThought via the telemetry ingest API
+                try:
+                    from datetime import datetime
+
+                    recording_data = {
+                        "recording": {
+                            "id": recording_summary["id"],
+                            "robotId": recording_summary["robot_id"],
+                            "skillId": recording_summary["skill_id"],
+                            "source": "hardware",  # Edge recording
+                            "startTime": datetime.fromtimestamp(_active_recording["start_time"]).isoformat(),
+                            "endTime": datetime.fromtimestamp(end_time).isoformat(),
+                            "success": success,
+                            "metadata": {
+                                "duration": duration,
+                                "frameRate": frame_count / duration if duration > 0 else 0,
+                                "totalFrames": frame_count,
+                                "tags": ["edge_recording", "mcp_tool"],
+                            },
+                            "frames": _active_recording.get("frames", []),
+                            "events": [],
+                        },
+                    }
+
+                    # Create labeling task if requested
+                    if create_labeling_task:
+                        recording_data["createLabelingTask"] = True
+
+                    response = client._request("POST", "/telemetry/ingest", json=recording_data)
+
+                    artifact_id = response.get("data", {}).get("artifactId", "")
+                    result_text += f"\n## Uploaded to FoodforThought\n"
+                    result_text += f"**Artifact ID:** {artifact_id}\n"
+                    result_text += f"**URL:** https://foodforthought.kindly.fyi/artifacts/{artifact_id}\n"
+
+                    if create_labeling_task:
+                        task_id = response.get("data", {}).get("taskId", "")
+                        if task_id:
+                            result_text += f"**Labeling Task:** https://foodforthought.kindly.fyi/labeling/{task_id}\n"
+                except Exception as e:
+                    result_text += f"\n## Upload Failed\n"
+                    result_text += f"Error: {str(e)}\n"
+                    result_text += "Recording saved locally. Try uploading manually later.\n"
+
+            if notes:
+                result_text += f"\n**Notes:** {notes}\n"
+
+            # Clear active recording
+            _active_recording = None
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_record_status":
+            global _active_recording
+            import time
+
+            if not _active_recording:
+                return [TextContent(type="text", text="No active recording session.")]
+
+            current_time = time.time()
+            elapsed = current_time - _active_recording["start_time"]
+            frame_count = len(_active_recording.get("frames", []))
+
+            result_text = f"# Recording Status\n\n"
+            result_text += f"**Recording ID:** {_active_recording['id']}\n"
+            result_text += f"**Robot:** {_active_recording['robot_id']}\n"
+            result_text += f"**Skill:** {_active_recording['skill_id']}\n"
+            result_text += f"**Elapsed:** {elapsed:.1f}s\n"
+            result_text += f"**Frames:** {frame_count}\n"
+            result_text += f"**Status:** Recording...\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_record_demonstration":
+            robot_id = arguments["robot_id"]
+            skill_id = arguments["skill_id"]
+            task_description = arguments["task_description"]
+            duration_seconds = arguments.get("duration_seconds", 30.0)
+            create_labeling_task = arguments.get("create_labeling_task", True)
+
+            import time
+            import uuid
+            from datetime import datetime
+
+            # Start recording
+            recording_id = str(uuid.uuid4())
+            start_time = time.time()
+
+            result_text = f"# Recording Demonstration\n\n"
+            result_text += f"**Recording ID:** {recording_id}\n"
+            result_text += f"**Robot:** {robot_id}\n"
+            result_text += f"**Skill:** {skill_id}\n"
+            result_text += f"**Task:** {task_description}\n"
+            result_text += f"**Duration:** {duration_seconds}s\n\n"
+
+            # Wait for the specified duration
+            # Note: In a real implementation, this would be collecting telemetry frames
+            # For now, we simulate the wait
+            result_text += f"Recording started at {datetime.now().isoformat()}\n"
+            result_text += f"Waiting {duration_seconds} seconds...\n\n"
+
+            # In production, we would collect frames here
+            # For MCP, we just note that recording would happen
+            time.sleep(min(duration_seconds, 5.0))  # Cap at 5s for responsiveness
+
+            end_time = time.time()
+            actual_duration = end_time - start_time
+
+            # Upload to FoodforThought
+            try:
+                recording_data = {
+                    "recording": {
+                        "id": recording_id,
+                        "robotId": robot_id,
+                        "skillId": skill_id,
+                        "source": "hardware",
+                        "startTime": datetime.fromtimestamp(start_time).isoformat(),
+                        "endTime": datetime.fromtimestamp(end_time).isoformat(),
+                        "success": True,
+                        "metadata": {
+                            "duration": actual_duration,
+                            "frameRate": 0,  # Placeholder
+                            "totalFrames": 0,  # Placeholder
+                            "tags": ["demonstration", "mcp_tool"],
+                            "task_description": task_description,
+                        },
+                        "frames": [],
+                        "events": [],
+                    },
+                }
+
+                if create_labeling_task:
+                    recording_data["createLabelingTask"] = True
+
+                response = client._request("POST", "/telemetry/ingest", json=recording_data)
+
+                artifact_id = response.get("data", {}).get("artifactId", "")
+                result_text += f"## Uploaded to FoodforThought\n\n"
+                result_text += f"**Artifact ID:** {artifact_id}\n"
+                result_text += f"**URL:** https://foodforthought.kindly.fyi/artifacts/{artifact_id}\n"
+
+                if create_labeling_task:
+                    task_id = response.get("data", {}).get("taskId", "")
+                    if task_id:
+                        result_text += f"**Labeling Task:** https://foodforthought.kindly.fyi/labeling/{task_id}\n"
+            except Exception as e:
+                result_text += f"## Upload Failed\n\nError: {str(e)}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_recordings_list":
+            # Query telemetry recordings from FoodforThought
+            params = {
+                "type": "trajectory",
+                "limit": arguments.get("limit", 20),
+            }
+
+            if arguments.get("robot_id"):
+                params["robotModel"] = arguments["robot_id"]
+            if arguments.get("skill_id"):
+                params["task"] = arguments["skill_id"]
+
+            try:
+                response = client._request("GET", "/artifacts", params=params)
+                artifacts = response.get("artifacts", [])
+
+                if not artifacts:
+                    return [TextContent(type="text", text="No recordings found.")]
+
+                result_text = f"# Telemetry Recordings\n\n"
+                result_text += f"Found {len(artifacts)} recording(s):\n\n"
+
+                for artifact in artifacts:
+                    metadata = artifact.get("metadata", {})
+                    result_text += f"## {artifact.get('name', 'Unnamed')}\n"
+                    result_text += f"- **ID:** {artifact.get('id')}\n"
+                    result_text += f"- **Robot:** {metadata.get('robotId', 'Unknown')}\n"
+                    result_text += f"- **Skill:** {metadata.get('skillId', 'Unknown')}\n"
+                    result_text += f"- **Duration:** {metadata.get('duration', 0):.1f}s\n"
+                    result_text += f"- **Frames:** {metadata.get('frameCount', 0)}\n"
+                    result_text += f"- **Success:** {'Yes' if metadata.get('success', True) else 'No'}\n"
+                    result_text += f"- **Source:** {metadata.get('source', 'Unknown')}\n"
+                    result_text += "\n"
+
+                return [TextContent(type="text", text=result_text)]
+            except Exception as e:
+                return [TextContent(type="text", text=f"Error fetching recordings: {str(e)}")]
+
         else:
             return [
                 TextContent(

ate/memory/__init__.py

@@ -0,0 +1,35 @@
+"""ATE Memory Library - Core memory operations with memvid-sdk backend."""
+
+from .store import MemoryStore
+from .search import SearchResult
+from .export import MemoryInfo
+from .merge import merge_memories
+from .embeddings import EmbeddingConfig, EmbeddingManager
+from .reranker import RerankConfig, LLMReranker
+from .context import ContextManager, MemoryContext, MemoryMetadata
+
+# Migration module imports
+from . import migrate
+from .migrate import (
+    VectorRecord,
+    MigrationEstimate,
+    MigrationResult,
+    MigrationCheckpoint,
+    MigrationSource,
+    MigrationPipeline,
+    PineconeMigrationSource,
+    QdrantMigrationSource,
+    WeaviateMigrationSource,
+    ChromaMigrationSource
+)
+
+__all__ = [
+    'MemoryStore', 'SearchResult', 'MemoryInfo', 'merge_memories',
+    'EmbeddingConfig', 'EmbeddingManager', 'RerankConfig', 'LLMReranker',
+    'ContextManager', 'MemoryContext', 'MemoryMetadata',
+    # Migration exports
+    'migrate', 'VectorRecord', 'MigrationEstimate', 'MigrationResult', 
+    'MigrationCheckpoint', 'MigrationSource', 'MigrationPipeline',
+    'PineconeMigrationSource', 'QdrantMigrationSource', 'WeaviateMigrationSource',
+    'ChromaMigrationSource'
+]

ate/memory/cloud.py

@@ -0,0 +1,244 @@
+"""
+Cloud client for FoodforThought memory API.
+
+Handles push (upload), pull (download), list, and delete of .mv2 memory files.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import List
+
+import requests
+
+
+# ---------------------------------------------------------------------------
+# Result dataclasses
+# ---------------------------------------------------------------------------
+
+@dataclass
+class PushResult:
+    id: str
+    name: str
+    project: str
+    size_bytes: int
+    url: str
+    created_at: str
+
+
+@dataclass
+class PullResult:
+    path: str
+    size_bytes: int
+    name: str
+    project: str
+
+
+@dataclass
+class MemoryListItem:
+    id: str
+    name: str
+    project: str
+    size_bytes: int
+    created_at: str
+    updated_at: str
+
+
+# ---------------------------------------------------------------------------
+# Exceptions
+# ---------------------------------------------------------------------------
+
+class CloudError(Exception):
+    """Base exception for cloud operations."""
+    pass
+
+
+class CloudAuthError(CloudError):
+    """Raised when authentication is missing or invalid."""
+    pass
+
+
+class CloudNotFoundError(CloudError):
+    """Raised when a requested resource is not found (404)."""
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Client
+# ---------------------------------------------------------------------------
+
+class CloudClient:
+    """Client for FoodforThought memory cloud API."""
+
+    def __init__(self, server_url: str = "https://kindly.fyi", token: str = None):
+        self.server_url = server_url.rstrip("/")
+        self.token = token
+
+    # -- public API --------------------------------------------------------
+
+    def push(self, local_path: str, project: str, name: str = None) -> PushResult:
+        """Upload .mv2 file to cloud.
+
+        POST /api/memory/upload (multipart/form-data)
+
+        Args:
+            local_path: Path to the local .mv2 file.
+            project: Project identifier (e.g. "kindly/memories").
+            name: Optional name override; defaults to the file's basename.
+
+        Returns:
+            PushResult with upload details.
+
+        Raises:
+            CloudAuthError: If no token is set.
+            CloudError: On server error.
+        """
+        headers = self._auth_headers()
+        resolved_name = name or os.path.basename(local_path)
+
+        url = f"{self.server_url}/api/memory/upload"
+
+        with open(local_path, "rb") as f:
+            resp = requests.post(
+                url,
+                headers=headers,
+                files={"file": (resolved_name, f)},
+                data={"project": project, "name": resolved_name},
+            )
+
+        if resp.status_code == 401:
+            raise CloudAuthError("Invalid or expired token")
+        if resp.status_code >= 400:
+            raise CloudError(f"Push failed ({resp.status_code}): {resp.text}")
+
+        body = resp.json()
+        return PushResult(
+            id=body["id"],
+            name=body["name"],
+            project=body["project"],
+            size_bytes=body["size_bytes"],
+            url=body["url"],
+            created_at=body["created_at"],
+        )
+
+    def pull(self, project: str, name: str, output_path: str) -> PullResult:
+        """Download .mv2 file from cloud.
+
+        GET /api/memory/{project}/{name}
+
+        Args:
+            project: Project identifier.
+            name: Memory file name.
+            output_path: Local path to write the downloaded file.
+
+        Returns:
+            PullResult with download details.
+
+        Raises:
+            CloudAuthError: If no token is set.
+            CloudNotFoundError: If the file is not found (404).
+            CloudError: On server error.
+        """
+        headers = self._auth_headers()
+        url = f"{self.server_url}/api/memory/{project}/{name}"
+
+        resp = requests.get(url, headers=headers)
+
+        if resp.status_code == 404:
+            raise CloudNotFoundError(f"Not found: {project}/{name}")
+        if resp.status_code == 401:
+            raise CloudAuthError("Invalid or expired token")
+        if resp.status_code >= 400:
+            raise CloudError(f"Pull failed ({resp.status_code}): {resp.text}")
+
+        # Write content to disk
+        parent = os.path.dirname(output_path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+
+        with open(output_path, "wb") as f:
+            f.write(resp.content)
+
+        size = len(resp.content)
+        return PullResult(
+            path=output_path,
+            size_bytes=size,
+            name=name,
+            project=project,
+        )
+
+    def list(self, project: str) -> List[MemoryListItem]:
+        """List memory files in a project.
+
+        GET /api/memory/list?project={project}
+
+        Args:
+            project: Project identifier.
+
+        Returns:
+            List of MemoryListItem.
+
+        Raises:
+            CloudAuthError: If no token is set.
+            CloudError: On server error.
+        """
+        headers = self._auth_headers()
+        url = f"{self.server_url}/api/memory/list"
+
+        resp = requests.get(url, headers=headers, params={"project": project})
+
+        if resp.status_code == 401:
+            raise CloudAuthError("Invalid or expired token")
+        if resp.status_code >= 400:
+            raise CloudError(f"List failed ({resp.status_code}): {resp.text}")
+
+        body = resp.json()
+        return [
+            MemoryListItem(
+                id=item["id"],
+                name=item["name"],
+                project=item["project"],
+                size_bytes=item["size_bytes"],
+                created_at=item["created_at"],
+                updated_at=item["updated_at"],
+            )
+            for item in body.get("items", [])
+        ]
+
+    def delete(self, project: str, name: str) -> bool:
+        """Delete a memory file from cloud.
+
+        DELETE /api/memory/{project}/{name}
+
+        Args:
+            project: Project identifier.
+            name: Memory file name.
+
+        Returns:
+            True on success.
+
+        Raises:
+            CloudAuthError: If no token is set.
+            CloudNotFoundError: If the file is not found (404).
+            CloudError: On server error.
+        """
+        headers = self._auth_headers()
+        url = f"{self.server_url}/api/memory/{project}/{name}"
+
+        resp = requests.delete(url, headers=headers)
+
+        if resp.status_code == 404:
+            raise CloudNotFoundError(f"Not found: {project}/{name}")
+        if resp.status_code == 401:
+            raise CloudAuthError("Invalid or expired token")
+        if resp.status_code >= 400:
+            raise CloudError(f"Delete failed ({resp.status_code}): {resp.text}")
+
+        return True
+
+    # -- internal ----------------------------------------------------------
+
+    def _auth_headers(self) -> dict:
+        """Build authorization headers."""
+        if not self.token:
+            raise CloudAuthError("Not authenticated. Run: ate device-login")
+        return {"Authorization": f"Bearer {self.token}"}