nia-mcp-server 1.0.25__py3-none-any.whl → 1.0.27__py3-none-any.whl

nia_mcp_server/server.py

@@ -72,59 +72,188 @@ async def ensure_api_client() -> NIAApiClient:
             raise ValueError("Failed to validate API key. Check logs for details.")
     return api_client
 
+def _detect_resource_type(url: str) -> str:
+    """Detect if URL is a GitHub repository or documentation.
+
+    Args:
+        url: The URL to analyze
+
+    Returns:
+        "repository" if GitHub URL or repository pattern, "documentation" otherwise
+    """
+    import re
+    from urllib.parse import urlparse
+
+    try:
+        # First, check for repository-like patterns
+        # Pattern 1: owner/repo format (simple case with single slash)
+        if re.match(r'^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+$', url):
+            return "repository"
+
+        # Pattern 2: Git SSH format (git@github.com:owner/repo.git)
+        if url.startswith('git@'):
+            return "repository"
+
+        # Pattern 3: Git protocol (git://...)
+        if url.startswith('git://'):
+            return "repository"
+
+        # Pattern 4: Ends with .git
+        if url.endswith('.git'):
+            return "repository"
+
+        # Pattern 5: owner/repo/tree/branch or owner/repo/tree/branch/... format
+        if re.match(r'^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+/tree/.+', url):
+            return "repository"
+
+        # Parse as URL for domain-based detection
+        parsed = urlparse(url)
+        # Only treat as repository if it's actually the github.com domain
+        netloc = parsed.netloc.lower()
+        if netloc == "github.com" or netloc == "www.github.com":
+            return "repository"
+
+        return "documentation"
+    except Exception:
+        # Fallback to documentation if parsing fails
+        return "documentation"
+
 # Tools
 
 @mcp.tool()
-async def index_repository(
-    repo_url: str,
-    branch: Optional[str] = None
+async def index(
+    url: str,
+    resource_type: Optional[str] = None,
+    branch: Optional[str] = None,
+    url_patterns: Optional[List[str]] = None,
+    exclude_patterns: Optional[List[str]] = None,
+    max_age: Optional[int] = None,
+    only_main_content: Optional[bool] = True,
+    wait_for: Optional[int] = None,
+    include_screenshot: Optional[bool] = None,
+    check_llms_txt: Optional[bool] = True,
+    llms_txt_strategy: Optional[str] = "prefer"
 ) -> List[TextContent]:
     """
-    Index a GitHub repository for intelligent code search.
-    
+    Universal indexing tool - intelligently indexes GitHub repositories or documentation.
+
+    Auto-detects resource type from URL:
+    - GitHub URLs (containing "github.com") → Repository indexing
+    - All other URLs → Documentation indexing
+
     Args:
-        repo_url: GitHub repository URL (e.g., https://github.com/owner/repo or https://github.com/owner/repo/tree/branch)
+        url: GitHub repository URL or documentation site URL (required)
+        resource_type: Optional override - "repository" or "documentation" (auto-detected if not provided)
+
+        # Repository-specific parameters:
         branch: Branch to index (optional, defaults to main branch)
-        
+
+        # Documentation-specific parameters:
+        url_patterns: Optional list of URL patterns to include in crawling
+        exclude_patterns: Optional list of URL patterns to exclude from crawling
+        max_age: Maximum age of cached content in days
+        only_main_content: Extract only main content (default: True)
+        wait_for: Time to wait for page load in milliseconds
+        include_screenshot: Include screenshots of pages
+        check_llms_txt: Check for llms.txt file (default: True)
+        llms_txt_strategy: Strategy for llms.txt - "prefer", "only", or "ignore" (default: "prefer")
+
     Returns:
         Status of the indexing operation
-    
+
+    Examples:
+        # Index a GitHub repository (auto-detected)
+        index("https://github.com/owner/repo", branch="main")
+
+        # Index documentation (auto-detected)
+        index("https://docs.example.com", url_patterns=["*/api/*"])
+
+        # Manual override (if needed for edge cases)
+        index("https://github.io/docs", resource_type="documentation")
+
     Important:
-        - When started indexing, prompt users to either use check_repository_status tool or go to app.trynia.ai to check the status.
+        - When indexing starts, use check_resource_status to monitor progress
+        - Repository identifier format: owner/repo or owner/repo/tree/branch
     """
     try:
         client = await ensure_api_client()
-        
-        # Start indexing
-        logger.info(f"Starting to index repository: {repo_url}")
-        result = await client.index_repository(repo_url, branch)
-        
-        repository = result.get("repository", repo_url)
-        status = result.get("status", "unknown")
-        
-        if status == "completed":
-            return [TextContent(
-                type="text",
-                text=f"✅ Repository already indexed: {repository}\n"
-                     f"Branch: {result.get('branch', 'main')}\n"
-                     f"You can now search this codebase!"
-            )]
+
+        # Detect or validate resource type
+        if resource_type:
+            if resource_type not in ["repository", "documentation"]:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Invalid resource_type: '{resource_type}'. Must be 'repository' or 'documentation'."
+                )]
+            detected_type = resource_type
         else:
-            # Wait for indexing to complete
-            return [TextContent(
-                type="text",
-                text=f"⏳ Indexing started for: {repository}\n"
-                     f"Branch: {branch or 'default'}\n"
-                     f"Status: {status}\n\n"
-                     f"Use `check_repository_status` to monitor progress."
-            )]
-            
+            detected_type = _detect_resource_type(url)
+
+        logger.info(f"Indexing {detected_type}: {url}")
+
+        # Route to appropriate indexing method
+        if detected_type == "repository":
+            # Index repository
+            result = await client.index_repository(url, branch)
+
+            repository = result.get("repository", url)
+            status = result.get("status", "unknown")
+
+            if status == "completed":
+                return [TextContent(
+                    type="text",
+                    text=f"✅ Repository already indexed: {repository}\n"
+                         f"Branch: {result.get('branch', 'main')}\n"
+                         f"You can now search this codebase!"
+                )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"⏳ Indexing started for: {repository}\n"
+                         f"Branch: {branch or 'default'}\n"
+                         f"Status: {status}\n\n"
+                         f"Use `check_resource_status(\"repository\", \"{repository}\")` to monitor progress."
+                )]
+
+        else:  # documentation
+            # Index documentation
+            result = await client.create_data_source(
+                url=url,
+                url_patterns=url_patterns,
+                exclude_patterns=exclude_patterns,
+                max_age=max_age,
+                only_main_content=only_main_content,
+                wait_for=wait_for,
+                include_screenshot=include_screenshot,
+                check_llms_txt=check_llms_txt,
+                llms_txt_strategy=llms_txt_strategy
+            )
+
+            source_id = result.get("id")
+            status = result.get("status", "unknown")
+
+            if status == "completed":
+                return [TextContent(
+                    type="text",
+                    text=f"✅ Documentation already indexed: {url}\n"
+                         f"Source ID: {source_id}\n"
+                         f"You can now search this documentation!"
+                )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"⏳ Documentation indexing started: {url}\n"
+                         f"Source ID: {source_id}\n"
+                         f"Status: {status}\n\n"
+                         f"Use `check_resource_status(\"documentation\", \"{source_id}\")` to monitor progress."
+                )]
+
     except APIError as e:
-        logger.error(f"API Error indexing repository: {e} (status_code={e.status_code}, detail={e.detail})")
+        logger.error(f"API Error indexing {detected_type}: {e} (status_code={e.status_code}, detail={e.detail})")
         if e.status_code == 403 or "free tier limit" in str(e).lower() or "indexing operations" in str(e).lower():
             if e.detail and "3 free indexing operations" in e.detail:
                 return [TextContent(
-                    type="text", 
+                    type="text",
                     text=f"❌ {e.detail}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
                 )]
             else:
@@ -135,7 +264,7 @@ async def index_repository(
         else:
             return [TextContent(type="text", text=f"❌ {str(e)}")]
     except Exception as e:
-        logger.error(f"Unexpected error indexing repository: {e}")
+        logger.error(f"Unexpected error indexing: {e}")
         error_msg = str(e)
         if "indexing operations" in error_msg.lower() or "lifetime limit" in error_msg.lower():
             return [TextContent(
@@ -144,9 +273,79 @@ async def index_repository(
             )]
         return [TextContent(
             type="text",
-            text=f"❌ Error indexing repository: {error_msg}"
+            text=f"❌ Error indexing: {error_msg}"
         )]
 
+# @mcp.tool()
+# async def index_repository(
+#     repo_url: str,
+#     branch: Optional[str] = None
+# ) -> List[TextContent]:
+#     """
+#     DEPRECATED: Use the unified `index` tool instead.
+#
+#     Args:
+#         repo_url: GitHub repository URL (e.g., https://github.com/owner/repo or https://github.com/owner/repo/tree/branch)
+#         branch: Branch to index (optional, defaults to main branch)
+#
+#     Important:
+#         - When started indexing, prompt users to either use check_repository_status tool or go to app.trynia.ai to check the status.
+#     """
+#     try:
+#         client = await ensure_api_client()
+#
+#         # Start indexing
+#         logger.info(f"Starting to index repository: {repo_url}")
+#         result = await client.index_repository(repo_url, branch)
+#
+#         repository = result.get("repository", repo_url)
+#         status = result.get("status", "unknown")
+#
+#         if status == "completed":
+#             return [TextContent(
+#                 type="text",
+#                 text=f"✅ Repository already indexed: {repository}\n"
+#                      f"Branch: {result.get('branch', 'main')}\n"
+#                      f"You can now search this codebase!"
+#             )]
+#         else:
+#             # Wait for indexing to complete
+#             return [TextContent(
+#                 type="text",
+#                 text=f"⏳ Indexing started for: {repository}\n"
+#                      f"Branch: {branch or 'default'}\n"
+#                      f"Status: {status}\n\n"
+#                      f"Use `check_repository_status` to monitor progress."
+#             )]
+#
+#     except APIError as e:
+#         logger.error(f"API Error indexing repository: {e} (status_code={e.status_code}, detail={e.detail})")
+#         if e.status_code == 403 or "free tier limit" in str(e).lower() or "indexing operations" in str(e).lower():
+#             if e.detail and "3 free indexing operations" in e.detail:
+#                 return [TextContent(
+#                     type="text",
+#                     text=f"❌ {e.detail}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
+#                 )]
+#             else:
+#                 return [TextContent(
+#                     type="text",
+#                     text=f"❌ {str(e)}\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
+#                 )]
+#         else:
+#             return [TextContent(type="text", text=f"❌ {str(e)}")]
+#     except Exception as e:
+#         logger.error(f"Unexpected error indexing repository: {e}")
+#         error_msg = str(e)
+#         if "indexing operations" in error_msg.lower() or "lifetime limit" in error_msg.lower():
+#             return [TextContent(
+#                 type="text",
+#                 text=f"❌ {error_msg}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
+#             )]
+#         return [TextContent(
+#             type="text",
+#             text=f"❌ Error indexing repository: {error_msg}"
+#         )]
+
 @mcp.tool()
 async def search_codebase(
     query: str,
@@ -157,31 +356,12 @@ async def search_codebase(
     Search indexed repositories using natural language.
     
     Args:
-        query: Natural language search query. Don't just use keywords or unstrctured query, make a comprehensive question to get the best results possible.
-        repositories: List of repositories to search (owner/repo or owner/repo/tree/branch if indexed differently before).
-            - "owner/repo" - Search entire repository (e.g., "facebook/react")
-            - "owner/repo/tree/branch/folder" - Search specific folder indexed separately
-              (e.g., "PostHog/posthog/tree/master/docs")
-            Use the EXACT format shown in list_repositories output for folder-indexed repos.
-            If not specified, searches all indexed repos.
-        include_sources: Whether to include source code in results
+        query: Natural language search query.
+        repositories: List of repositories to search (owner/repo or owner/repo/tree/branch).
+        include_sources: default to True.
         
     Returns:
         Search results with relevant code snippets and explanations
-        
-    Examples:
-        # Search all indexed repositories
-        search_codebase("How does authentication work?")
-        
-        # Search specific repository
-        search_codebase("How to create custom hooks?", ["facebook/react"])
-        
-        # Search folder-indexed repository (use exact format from list_repositories)
-        search_codebase("What is Flox?", ["PostHog/posthog/tree/master/docs"])
-
-    Important:
-        - If you want to search a specific folder, use the EXACT repository path shown above
-        - Example: `search_codebase(\"query\", [\"owner/repo/tree/branch/folder\"])`
     """
     try:
         client = await ensure_api_client()
@@ -324,6 +504,164 @@ async def search_codebase(
             text=f"❌ Error searching codebase: {error_msg}"
         )]
 
+@mcp.tool()
+async def regex_search(
+    repositories: List[str],
+    query: str,
+    pattern: Optional[str] = None,
+    file_extensions: Optional[List[str]] = None,
+    languages: Optional[List[str]] = None,
+    max_results: int = 50,
+    include_context: bool = True,
+    context_lines: int = 3
+) -> List[TextContent]:
+    """
+    Perform regex pattern search over indexed repository source code.
+
+    Args:
+        repositories: List of repositories to search (owner/repo format)
+        query: Natural language query or regex pattern (e.g., "function handleSubmit", "class UserController", "/async\\s+function/")
+        pattern: Optional explicit regex pattern (overrides automatic extraction from query)
+        file_extensions: File extensions to filter (e.g., [".js", ".tsx", ".py"])
+        languages: Programming languages to filter (e.g., ["python", "javascript", "typescript"])
+        max_results: Maximum number of results to return (default: 50)
+        include_context: Include surrounding context lines (default: True)
+        context_lines: Number of context lines before/after match (default: 3)
+
+    Returns:
+        Regex search results with exact matches, file locations, and context
+
+    Examples:
+        - Natural language: `regex_search(["owner/repo"], "function handleSubmit")`
+        - Direct regex: `regex_search(["owner/repo"], "/async\\s+function\\s+\\w+/")`
+        - With filters: `regex_search(["owner/repo"], "class Controller", file_extensions=[".py"])`
+    """
+    try:
+        client = await ensure_api_client()
+
+        # Require explicit repository selection
+        if not repositories:
+            return [TextContent(
+                type="text",
+                text="🔍 **Please specify which repositories to search:**\n\n"
+                     "1. Use `list_repositories` to see available repositories\n"
+                     "2. Then call `regex_search([\"owner/repo\"], \"pattern\")`\n\n"
+                     "**Examples:**\n"
+                     "```python\n"
+                     "# Natural language pattern\n"
+                     "regex_search([\"facebook/react\"], \"function useState\")\n\n"
+                     "# Direct regex pattern\n"
+                     "regex_search([\"django/django\"], \"/class\\s+\\w+Admin/\")\n\n"
+                     "# With file filters\n"
+                     "regex_search([\"owner/repo\"], \"import React\", file_extensions=[\".tsx\"])\n"
+                     "```"
+            )]
+
+        logger.info(f"Performing regex search in {len(repositories)} repositories for query: {query}")
+
+        # Call the regex search API
+        result = await client.regex_search(
+            repositories=repositories,
+            query=query,
+            pattern=pattern,
+            file_extensions=file_extensions,
+            languages=languages,
+            max_results=max_results,
+            include_context=include_context,
+            context_lines=context_lines
+        )
+
+        # Check for errors
+        if not result.get("success"):
+            error_msg = result.get("error", "Unknown error")
+            return [TextContent(
+                type="text",
+                text=f"❌ **Regex Search Error:** {error_msg}"
+            )]
+
+        # Format the results
+        response_parts = []
+
+        # Add search summary
+        total_matches = result.get("total_matches", 0)
+        total_files = result.get("total_files", 0)
+        pattern_used = result.get("pattern", query)
+
+        summary = f"🔍 **Regex Search Results**\n\n"
+        summary += f"**Query:** `{query}`\n"
+        if pattern and pattern != query:
+            summary += f"**Pattern Used:** `{pattern_used}`\n"
+        summary += f"**Matches Found:** {total_matches} matches in {total_files} files\n"
+
+        if file_extensions:
+            summary += f"**File Extensions:** {', '.join(file_extensions)}\n"
+        if languages:
+            summary += f"**Languages:** {', '.join(languages)}\n"
+
+        response_parts.append(summary)
+        response_parts.append("\n---\n")
+
+        # Add the actual results
+        results = result.get("results", [])
+
+        if not results:
+            response_parts.append("\n📭 No matches found for the given pattern.")
+        else:
+            # Group results by file
+            file_matches = {}
+            for match in results:
+                file_path = match.get("file_path", "Unknown")
+                if file_path not in file_matches:
+                    file_matches[file_path] = []
+                file_matches[file_path].append(match)
+
+            # Format each file's matches
+            for file_path, matches in file_matches.items():
+                response_parts.append(f"\n### 📄 `{file_path}`\n")
+
+                for match in matches:
+                    line_number = match.get("line_number", 0)
+                    matched_text = match.get("matched_text", "")
+                    context = match.get("context", "")
+
+                    response_parts.append(f"\n**Line {line_number}:** `{matched_text}`\n")
+
+                    if include_context and context:
+                        # Format context with line numbers
+                        context_start = match.get("context_start_line", line_number)
+                        response_parts.append("\n```\n")
+                        context_lines_list = context.split('\n')
+                        for i, line in enumerate(context_lines_list):
+                            current_line_num = context_start + i
+                            marker = ">" if current_line_num == line_number else " "
+                            response_parts.append(f"{marker}{current_line_num:4d}: {line}\n")
+                        response_parts.append("```\n")
+
+        # Add search hints if available
+        search_hints = result.get("search_hints", {})
+        if search_hints and search_hints.get("is_regex"):
+            response_parts.append("\n---\n")
+            response_parts.append("💡 **Search Hints:**\n")
+            if search_hints.get("case_sensitive"):
+                response_parts.append("- Case-sensitive search enabled\n")
+            if search_hints.get("whole_word"):
+                response_parts.append("- Whole word matching enabled\n")
+
+        # Combine all parts into final response
+        full_response = "".join(response_parts)
+
+        return [TextContent(
+            type="text",
+            text=full_response
+        )]
+
+    except Exception as e:
+        logger.error(f"Regex search error: {e}", exc_info=True)
+        return [TextContent(
+            type="text",
+            text=f"❌ **Regex Search Error:** {str(e)}"
+        )]
+
 @mcp.tool()
 async def search_documentation(
     query: str,
@@ -336,18 +674,11 @@ async def search_documentation(
     Args:
         query: Natural language search query. Don't just use keywords or unstrctured query, make a comprehensive question to get the best results possible.
         sources: List of documentation identifiers to search. Preferred format is UUID, but also supports:
-            - Source UUIDs (e.g., "550e8400-e29b-41d4-a716-446655440000") - RECOMMENDED
-            - Display names (e.g., "Vercel AI SDK - Core")
-            - URLs (e.g., "https://sdk.vercel.ai/docs")
-        include_sources: Whether to include source references in results
-
-    Returns:
-        Search results with relevant documentation excerpts
-
+            - Source UUIDs - RECOMMENDED
+            - Display names 
+            - URLs
     Important:
         - UUIDs are the preferred identifier format for best performance
-        - Use `list_documentation` tool to see available sources and their UUIDs
-        - Display names and URLs are also supported for convenience
     """
     try:
         client = await ensure_api_client()
@@ -474,9 +805,7 @@ async def search_documentation(
 
 # @mcp.tool()
 # async def list_repositories() -> List[TextContent]:
-    """
-    List all indexed repositories.
-    
+    """    
     Returns:
         List of indexed repositories with their status
     """
@@ -563,9 +892,6 @@ async def search_documentation(
     
     Args:
         repository: Repository in owner/repo format
-        
-    Returns:
-        Current status of the repository
     """
     try:
         client = await ensure_api_client()
@@ -619,97 +945,80 @@ async def search_documentation(
             text=f"❌ Error checking repository status: {str(e)}"
         )]
 
-@mcp.tool()
-async def index_documentation(
-    url: str,
-    url_patterns: Optional[List[str]] = None,
-    exclude_patterns: Optional[List[str]] = None,
-    max_age: Optional[int] = None,
-    only_main_content: Optional[bool] = True,
-    wait_for: Optional[int] = None,
-    include_screenshot: Optional[bool] = None,
-    check_llms_txt: Optional[bool] = True,
-    llms_txt_strategy: Optional[str] = "prefer"
-) -> List[TextContent]:
-    """
-    Index documentation or website for intelligent search.
-    
-    Args:
-        url: URL of the documentation site to index
-        url_patterns: Optional list of URL patterns to include in crawling (e.g., ["/docs/*", "/guide/*"])
-        exclude_patterns: Optional list of URL patterns to exclude from crawling (e.g., ["/blog/*", "/changelog/*"])
-        max_age: Maximum age of cached content in seconds (for fast scraping mode)
-        only_main_content: Extract only main content (removes navigation, ads, etc.)
-        wait_for: Time to wait for page to load in milliseconds (defaults to backend setting)
-        include_screenshot: Whether to capture full page screenshots (defaults to backend setting)
-        check_llms_txt: Check for llms.txt file for curated documentation URLs (default: True)
-        llms_txt_strategy: How to use llms.txt if found:
-            - "prefer": Start with llms.txt URLs, then crawl additional pages if under limit
-            - "only": Only index URLs listed in llms.txt
-            - "ignore": Skip llms.txt check (traditional behavior)
-        
-    Returns:
-        Status of the indexing operation
-
-    Important:
-        - When started indexing, prompt users to either use check_documentation_status tool or go to app.trynia.ai to check the status.
-        - By default, crawls the entire domain (up to 10,000 pages)
-        - Use exclude_patterns to filter out unwanted sections like blogs, changelogs, etc.
-    """
-    try:
-        client = await ensure_api_client()
-        
-        # Create and start indexing
-        logger.info(f"Starting to index documentation: {url}")
-        result = await client.create_data_source(
-            url=url, 
-            url_patterns=url_patterns,
-            exclude_patterns=exclude_patterns,
-            max_age=max_age,
-            only_main_content=only_main_content,
-            wait_for=wait_for,
-            include_screenshot=include_screenshot,
-            check_llms_txt=check_llms_txt,
-            llms_txt_strategy=llms_txt_strategy
-        )
-        
-        source_id = result.get("id")
-        status = result.get("status", "unknown")
-        
-        if status == "completed":
-            return [TextContent(
-                type="text",
-                text=f"✅ Documentation already indexed: {url}\n"
-                     f"Source ID: {source_id}\n"
-                     f"You can now search this documentation!"
-            )]
-        else:
-            return [TextContent(
-                type="text",
-                text=f"⏳ Documentation indexing started: {url}\n"
-                     f"Source ID: {source_id}\n"
-                     f"Status: {status}\n\n"
-                     f"Use `check_documentation_status` to monitor progress."
-            )]
-            
-    except APIError as e:
-        logger.error(f"API Error indexing documentation: {e}")
-        error_msg = f"❌ {str(e)}"
-        if e.status_code == 403 and "lifetime limit" in str(e).lower():
-            error_msg += "\n\n💡 Tip: You've reached the free tier limit of 3 indexing operations. Upgrade to Pro for unlimited access."
-        return [TextContent(type="text", text=error_msg)]
-    except Exception as e:
-        logger.error(f"Error indexing documentation: {e}")
-        return [TextContent(
-            type="text",
-            text=f"❌ Error indexing documentation: {str(e)}"
-        )]
+# @mcp.tool()
+# async def index_documentation(
+#     url: str,
+#     url_patterns: Optional[List[str]] = None,
+#     exclude_patterns: Optional[List[str]] = None,
+#     max_age: Optional[int] = None,
+#     only_main_content: Optional[bool] = True,
+#     wait_for: Optional[int] = None,
+#     include_screenshot: Optional[bool] = None,
+#     check_llms_txt: Optional[bool] = True,
+#     llms_txt_strategy: Optional[str] = "prefer"
+# ) -> List[TextContent]:
+#     """
+#     DEPRECATED: Use the unified `index` tool instead.
+#
+#     Index documentation or website for intelligent search.
+#
+#     Args:
+#         url: URL of the documentation site to index
+#         url_patterns: Optional list of URL patterns to include in crawling
+#         exclude_patterns: Optional list of URL patterns to exclude from crawling
+#     """
+#     try:
+#         client = await ensure_api_client()
+#
+#         # Create and start indexing
+#         logger.info(f"Starting to index documentation: {url}")
+#         result = await client.create_data_source(
+#             url=url,
+#             url_patterns=url_patterns,
+#             exclude_patterns=exclude_patterns,
+#             max_age=max_age,
+#             only_main_content=only_main_content,
+#             wait_for=wait_for,
+#             include_screenshot=include_screenshot,
+#             check_llms_txt=check_llms_txt,
+#             llms_txt_strategy=llms_txt_strategy
+#         )
+#
+#         source_id = result.get("id")
+#         status = result.get("status", "unknown")
+#
+#         if status == "completed":
+#             return [TextContent(
+#                 type="text",
+#                 text=f"✅ Documentation already indexed: {url}\n"
+#                      f"Source ID: {source_id}\n"
+#                      f"You can now search this documentation!"
+#             )]
+#         else:
+#             return [TextContent(
+#                 type="text",
+#                 text=f"⏳ Documentation indexing started: {url}\n"
+#                      f"Source ID: {source_id}\n"
+#                      f"Status: {status}\n\n"
+#                      f"Use `check_documentation_status` to monitor progress."
+#             )]
+#
+#     except APIError as e:
+#         logger.error(f"API Error indexing documentation: {e}")
+#         error_msg = f"❌ {str(e)}"
+#         if e.status_code == 403 and "lifetime limit" in str(e).lower():
+#             error_msg += "\n\n💡 Tip: You've reached the free tier limit of 3 indexing operations. Upgrade to Pro for unlimited access."
+#         return [TextContent(type="text", text=error_msg)]
+#     except Exception as e:
+#         logger.error(f"Error indexing documentation: {e}")
+#         return [TextContent(
+#             type="text",
+#             text=f"❌ Error indexing documentation: {str(e)}"
+#         )]
 
 # @mcp.tool()
 # async def list_documentation() -> List[TextContent]:
     """
-    List all indexed documentation sources.
-    
     Returns:
         List of indexed documentation with their status
     """
@@ -767,8 +1076,6 @@ async def index_documentation(
 # @mcp.tool()
 # async def check_documentation_status(source_id: str) -> List[TextContent]:
     """
-    Check the indexing status of a documentation source.
-    
     Args:
         source_id: Documentation source ID
         
@@ -833,98 +1140,458 @@ async def index_documentation(
 # Combined Resource Management Tools
 
 @mcp.tool()
-async def rename_resource(
-    resource_type: str,
-    identifier: str,
-    new_name: str
+async def manage_resource(
+    action: str,
+    resource_type: Optional[str] = None,
+    identifier: Optional[str] = None,
+    new_name: Optional[str] = None
 ) -> List[TextContent]:
     """
-    Rename a resource (repository or documentation) for better organization.
+    Unified resource management tool for repositories and documentation.
 
     Args:
-        resource_type: Type of resource - "repository" or "documentation"
-        identifier:
-            - For repository: Repository in owner/repo format (e.g., "facebook/react")
-            - For documentation: UUID preferred, also supports display name or URL (e.g., "550e8400-e29b-41d4-a716-446655440000", "Vercel AI SDK - Core", or "https://docs.trynia.ai/")
-        new_name: New display name for the resource (1-100 characters)
-
-    Returns:
-        Confirmation of rename operation
+        action: Action to perform - "list", "status", "rename", or "delete"
+        resource_type: Type of resource - "repository" or "documentation" (required for status/rename/delete, optional for list)
+        identifier: Resource identifier (required for status/rename/delete):
+            - For repos: Repository in owner/repo format (e.g., "facebook/react")
+            - For docs: UUID preferred, also supports display name or URL
+        new_name: New display name (required only for rename action, 1-100 characters)
 
     Examples:
-        - rename_resource("repository", "facebook/react", "React Framework")
-        - rename_resource("documentation", "550e8400-e29b-41d4-a716-446655440000", "Python Official Docs")
-        - rename_resource("documentation", "https://docs.trynia.ai/", "NIA Documentation")
+        # List all resources
+        manage_resource(action="list")
+
+        # List only repositories
+        manage_resource(action="list", resource_type="repository")
+
+        # Check status
+        manage_resource(action="status", resource_type="repository", identifier="owner/repo")
+
+        # Rename resource
+        manage_resource(action="rename", resource_type="repository", identifier="owner/repo", new_name="My Project")
+
+        # Delete resource
+        manage_resource(action="delete", resource_type="documentation", identifier="uuid-here")
     """
     try:
-        # Validate resource type
-        if resource_type not in ["repository", "documentation"]:
+        # Validate action
+        valid_actions = ["list", "status", "rename", "delete"]
+        if action not in valid_actions:
             return [TextContent(
                 type="text",
-                text=f"❌ Invalid resource_type: '{resource_type}'. Must be 'repository' or 'documentation'."
+                text=f"❌ Invalid action: '{action}'. Must be one of: {', '.join(valid_actions)}"
             )]
 
-        # Validate name length
-        if not new_name or len(new_name) > 100:
+        # Validate resource_type when provided
+        if resource_type and resource_type not in ["repository", "documentation"]:
             return [TextContent(
                 type="text",
-                text="❌ Display name must be between 1 and 100 characters."
+                text=f"❌ Invalid resource_type: '{resource_type}'. Must be 'repository' or 'documentation'."
             )]
 
+        # Validate required parameters based on action
+        if action in ["status", "rename", "delete"]:
+            if not resource_type:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ resource_type is required for action '{action}'"
+                )]
+            if not identifier:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ identifier is required for action '{action}'"
+                )]
+
+        if action == "rename":
+            if not new_name:
+                return [TextContent(
+                    type="text",
+                    text="❌ new_name is required for rename action"
+                )]
+            # Validate name length
+            if len(new_name) > 100:
+                return [TextContent(
+                    type="text",
+                    text="❌ Display name must be between 1 and 100 characters."
+                )]
+
         client = await ensure_api_client()
 
-        if resource_type == "repository":
-            result = await client.rename_repository(identifier, new_name)
-            resource_desc = f"repository '{identifier}'"
-        else:  # documentation
-            result = await client.rename_data_source(identifier, new_name)
-            resource_desc = f"documentation source"
+        # ===== LIST ACTION =====
+        if action == "list":
+            # Validate resource type if provided
+            if resource_type and resource_type not in ["repository", "documentation"]:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Invalid resource_type: '{resource_type}'. Must be 'repository', 'documentation', or None for all."
+                )]
 
-        if result.get("success"):
+            lines = []
+
+            # Determine what to list
+            list_repos = resource_type in [None, "repository"]
+            list_docs = resource_type in [None, "documentation"]
+
+            if list_repos:
+                repositories = await client.list_repositories()
+
+                if repositories:
+                    lines.append("# Indexed Repositories\n")
+                    for repo in repositories:
+                        status_icon = "✅" if repo.get("status") == "completed" else "⏳"
+
+                        # Show display name if available, otherwise show repository
+                        display_name = repo.get("display_name")
+                        repo_name = repo['repository']
+
+                        if display_name:
+                            lines.append(f"\n## {status_icon} {display_name}")
+                            lines.append(f"- **Repository:** {repo_name}")
+                        else:
+                            lines.append(f"\n## {status_icon} {repo_name}")
+
+                        lines.append(f"- **Branch:** {repo.get('branch', 'main')}")
+                        lines.append(f"- **Status:** {repo.get('status', 'unknown')}")
+                        if repo.get("indexed_at"):
+                            lines.append(f"- **Indexed:** {repo['indexed_at']}")
+                        if repo.get("error"):
+                            lines.append(f"- **Error:** {repo['error']}")
+
+                        # Add usage hint for completed repositories
+                        if repo.get("status") == "completed":
+                            lines.append(f"- **Usage:** `search_codebase(query, [\"{repo_name}\"])`")
+                elif resource_type == "repository":
+                    lines.append("No indexed repositories found.\n\n")
+                    lines.append("Get started by indexing a repository:\n")
+                    lines.append("Use `index` with a GitHub URL.")
+
+            if list_docs:
+                sources = await client.list_data_sources()
+
+                if sources:
+                    if lines:  # Add separator if we already have repositories
+                        lines.append("\n---\n")
+                    lines.append("# Indexed Documentation\n")
+
+                    for source in sources:
+                        status_icon = "✅" if source.get("status") == "completed" else "⏳"
+
+                        # Show display name if available, otherwise show URL
+                        display_name = source.get("display_name")
+                        url = source.get('url', 'Unknown URL')
+
+                        if display_name:
+                            lines.append(f"\n## {status_icon} {display_name}")
+                            lines.append(f"- **URL:** {url}")
+                        else:
+                            lines.append(f"\n## {status_icon} {url}")
+
+                        lines.append(f"- **ID:** {source['id']}")
+                        lines.append(f"- **Status:** {source.get('status', 'unknown')}")
+                        lines.append(f"- **Type:** {source.get('source_type', 'web')}")
+                        if source.get("page_count", 0) > 0:
+                            lines.append(f"- **Pages:** {source['page_count']}")
+                        if source.get("created_at"):
+                            lines.append(f"- **Created:** {source['created_at']}")
+                elif resource_type == "documentation":
+                    lines.append("No indexed documentation found.\n\n")
+                    lines.append("Get started by indexing documentation:\n")
+                    lines.append("Use `index` with a URL.")
+
+            if not lines:
+                lines.append("No indexed resources found.\n\n")
+                lines.append("Get started by indexing:\n")
+                lines.append("- Use `index` for GitHub repos or URLs\n")
+
+            return [TextContent(type="text", text="\n".join(lines))]
+
+        # ===== STATUS ACTION =====
+        elif action == "status":
+            if resource_type == "repository":
+                status = await client.get_repository_status(identifier)
+                if not status:
+                    return [TextContent(
+                        type="text",
+                        text=f"❌ Repository '{identifier}' not found."
+                    )]
+                title = f"Repository Status: {identifier}"
+                status_key = "status"
+            else:  # documentation
+                status = await client.get_data_source_status(identifier)
+                if not status:
+                    return [TextContent(
+                        type="text",
+                        text=f"❌ Documentation source '{identifier}' not found."
+                    )]
+                title = f"Documentation Status: {status.get('url', 'Unknown URL')}"
+                status_key = "status"
+
+            # Format status with appropriate icon
+            status_text = status.get(status_key, "unknown")
+            status_icon = {
+                "completed": "✅",
+                "indexing": "⏳",
+                "processing": "⏳",
+                "failed": "❌",
+                "pending": "🔄",
+                "error": "❌"
+            }.get(status_text, "❓")
+
+            lines = [
+                f"# {title}\n",
+                f"{status_icon} **Status:** {status_text}"
+            ]
+
+            # Add resource-specific fields
+            if resource_type == "repository":
+                lines.append(f"**Branch:** {status.get('branch', 'main')}")
+                if status.get("progress"):
+                    progress = status["progress"]
+                    if isinstance(progress, dict):
+                        lines.append(f"**Progress:** {progress.get('percentage', 0)}%")
+                        if progress.get("stage"):
+                            lines.append(f"**Stage:** {progress['stage']}")
+            else:  # documentation
+                lines.append(f"**Source ID:** {identifier}")
+                if status.get("page_count", 0) > 0:
+                    lines.append(f"**Pages Indexed:** {status['page_count']}")
+                if status.get("details"):
+                    details = status["details"]
+                    if details.get("progress"):
+                        lines.append(f"**Progress:** {details['progress']}%")
+                    if details.get("stage"):
+                        lines.append(f"**Stage:** {details['stage']}")
+
+            # Common fields
+            if status.get("indexed_at"):
+                lines.append(f"**Indexed:** {status['indexed_at']}")
+            elif status.get("created_at"):
+                lines.append(f"**Created:** {status['created_at']}")
+
+            if status.get("error"):
+                lines.append(f"**Error:** {status['error']}")
+
+            return [TextContent(type="text", text="\n".join(lines))]
+
+        # ===== RENAME ACTION =====
+        elif action == "rename":
+            if resource_type == "repository":
+                result = await client.rename_repository(identifier, new_name)
+                resource_desc = f"repository '{identifier}'"
+            else:  # documentation
+                result = await client.rename_data_source(identifier, new_name)
+                resource_desc = f"documentation source"
+
+            if result.get("success"):
+                return [TextContent(
+                    type="text",
+                    text=f"✅ Successfully renamed {resource_desc} to '{new_name}'"
+                )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Failed to rename {resource_type}: {result.get('message', 'Unknown error')}"
+                )]
+
+        # ===== DELETE ACTION =====
+        elif action == "delete":
+            if resource_type == "repository":
+                success = await client.delete_repository(identifier)
+                resource_desc = f"repository: {identifier}"
+            else:  # documentation
+                success = await client.delete_data_source(identifier)
+                resource_desc = f"documentation source: {identifier}"
+
+            if success:
+                return [TextContent(
+                    type="text",
+                    text=f"✅ Successfully deleted {resource_desc}"
+                )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Failed to delete {resource_desc}"
+                )]
+
+    except APIError as e:
+        logger.error(f"API Error in manage_resource ({action}): {e}")
+        error_msg = f"❌ {str(e)}"
+        if e.status_code == 403 or "free tier limit" in str(e).lower():
+            if e.detail and "3 free indexing operations" in e.detail:
+                error_msg = f"❌ {e.detail}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
+            else:
+                error_msg += "\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
+        return [TextContent(type="text", text=error_msg)]
+    except Exception as e:
+        logger.error(f"Error in manage_resource ({action}): {e}")
+        error_msg = str(e)
+        if "indexing operations" in error_msg.lower() or "lifetime limit" in error_msg.lower():
             return [TextContent(
                 type="text",
-                text=f"✅ Successfully renamed {resource_desc} to '{new_name}'"
+                text=f"❌ {error_msg}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
             )]
-        else:
+        return [TextContent(
+            type="text",
+            text=f"❌ Error in {action} operation: {error_msg}"
+        )]
+
+@mcp.tool()
+async def get_github_file_tree(
+    repository: str,
+    branch: Optional[str] = None,
+    include_paths: Optional[List[str]] = None,
+    exclude_paths: Optional[List[str]] = None,
+    file_extensions: Optional[List[str]] = None,
+    exclude_extensions: Optional[List[str]] = None,
+    show_full_paths: bool = False
+) -> List[TextContent]:
+    """
+    Get file and folder structure directly from GitHub API (no indexing required).
+
+    Args:
+        repository: Repository identifier (owner/repo format, e.g., "facebook/react")
+        branch: Optional branch name (defaults to repository's default branch)
+        include_paths: Only show files in these paths (e.g., ["src/", "lib/"])
+        exclude_paths: Hide files in these paths (e.g., ["node_modules/", "dist/", "test/"])
+        file_extensions: Only show these file types (e.g., [".py", ".js", ".ts"])
+        exclude_extensions: Hide these file types (e.g., [".md", ".lock", ".json"])
+        show_full_paths: Show full paths instead of tree structure (default: False)
+
+    Returns:
+        Filtered file tree structure from GitHub with stats
+    """
+    try:
+        client = await ensure_api_client()
+
+        # Require explicit repository specification
+        if not repository:
             return [TextContent(
                 type="text",
-                text=f"❌ Failed to rename {resource_type}: {result.get('message', 'Unknown error')}"
+                text="🔍 **Please specify which repository to get file tree from:**\n\n"
+                     "Usage: `get_github_file_tree(\"owner/repo\")`\n\n"
+                     "**Examples:**\n"
+                     "```\n"
+                     "get_github_file_tree(\"facebook/react\")\n"
+                     "get_github_file_tree(\"microsoft/vscode\", \"main\")\n"
+                     "```"
             )]
 
+        logger.info(f"Getting GitHub tree for repository: {repository}, branch: {branch or 'default'}, filters: {include_paths or exclude_paths or file_extensions or exclude_extensions}")
+
+        # Call API with filters
+        result = await client.get_github_tree(
+            repository,
+            branch=branch,
+            include_paths=include_paths,
+            exclude_paths=exclude_paths,
+            file_extensions=file_extensions,
+            exclude_extensions=exclude_extensions,
+            show_full_paths=show_full_paths
+        )
+
+        # Format response
+        response_text = f"# 📁 GitHub File Tree: {result.get('owner')}/{result.get('repo')}\n\n"
+        response_text += f"**Branch:** `{result.get('branch')}`\n"
+        response_text += f"**SHA:** `{result.get('sha')}`\n"
+        response_text += f"**Retrieved:** {result.get('retrieved_at')}\n"
+        response_text += f"**Source:** GitHub API (always current)\n"
+
+        # Show active filters
+        filters = result.get("filters_applied", {})
+        active_filters = []
+        if filters.get("include_paths"):
+            active_filters.append(f"📂 Included paths: {', '.join(filters['include_paths'])}")
+        if filters.get("exclude_paths"):
+            active_filters.append(f"🚫 Excluded paths: {', '.join(filters['exclude_paths'])}")
+        if filters.get("file_extensions"):
+            active_filters.append(f"📄 File types: {', '.join(filters['file_extensions'])}")
+        if filters.get("exclude_extensions"):
+            active_filters.append(f"🚫 Excluded types: {', '.join(filters['exclude_extensions'])}")
+        if filters.get("show_full_paths"):
+            active_filters.append(f"📍 Showing full paths")
+
+        if active_filters:
+            response_text += f"**Filters:** {' | '.join(active_filters)}\n"
+
+        response_text += "\n"
+
+        # Add stats
+        stats = result.get("stats", {})
+        response_text += "## 📊 Statistics\n\n"
+        response_text += f"- **Total Files:** {stats.get('total_files', 0)}\n"
+        response_text += f"- **Total Directories:** {stats.get('total_directories', 0)}\n"
+        response_text += f"- **Max Depth:** {stats.get('max_depth', 0)} levels\n"
+
+        # File extensions breakdown
+        file_extensions = stats.get("file_extensions", {})
+        if file_extensions:
+            response_text += f"\n**File Types:**\n"
+            sorted_extensions = sorted(file_extensions.items(), key=lambda x: x[1], reverse=True)
+            for ext, count in sorted_extensions[:10]:  # Show top 10
+                ext_name = ext if ext != "no_extension" else "(no extension)"
+                response_text += f"  - `{ext_name}`: {count} files\n"
+
+        # Tree structure (full)
+        tree_text = result.get("tree_text", "")
+        if tree_text:
+            response_text += "\n## 🌳 Directory Structure\n\n"
+            response_text += "```\n"
+            response_text += tree_text
+            response_text += "\n```\n"
+
+        # Truncation warning
+        if result.get("truncated"):
+            response_text += "\n⚠️ **Note:** Repository is very large. Tree may be truncated by GitHub.\n"
+
+        # Usage hints
+        response_text += "\n---\n"
+        response_text += "💡 **Next Steps:**\n"
+        response_text += f"- Index this repository: `index(\"{repository}\")`\n"
+        response_text += "- Refine with filters (examples below)\n"
+        response_text += "- Use `manage_resource(\"status\", \"repository\", \"{}\")` to check indexing status\n\n".format(repository)
+
+        # Show filter examples if no filters were used
+        if not active_filters:
+            response_text += "**Filter Examples:**\n"
+            response_text += f"- Only Python files: `file_extensions=[\".py\"]`\n"
+            response_text += f"- Exclude tests: `exclude_paths=[\"test/\", \"tests/\"]`\n"
+            response_text += f"- Only src directory: `include_paths=[\"src/\"]`\n"
+            response_text += f"- Full paths: `show_full_paths=True`\n"
+
+        return [TextContent(type="text", text=response_text)]
+
     except APIError as e:
-        logger.error(f"API Error renaming {resource_type}: {e}")
+        logger.error(f"API Error getting GitHub tree: {e}")
         error_msg = f"❌ {str(e)}"
-        if e.status_code == 403 and "lifetime limit" in str(e).lower():
-            error_msg += "\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
+        if e.status_code == 404:
+            error_msg = f"❌ Repository '{repository}' not found or not accessible.\n\n"
+            error_msg += "**Possible reasons:**\n"
+            error_msg += "- Repository doesn't exist\n"
+            error_msg += "- Repository is private and GitHub App not installed\n"
+            error_msg += "- Invalid owner/repo format\n\n"
+            error_msg += "**Note:** You must have the repository indexed first, or have GitHub App installed."
         return [TextContent(type="text", text=error_msg)]
     except Exception as e:
-        logger.error(f"Error renaming {resource_type}: {e}")
+        logger.error(f"Error getting GitHub tree: {e}")
         return [TextContent(
             type="text",
-            text=f"❌ Error renaming {resource_type}: {str(e)}"
+            text=f"❌ Error getting GitHub file tree: {str(e)}"
         )]
 
-@mcp.tool()
-async def delete_resource(
-    resource_type: str,
-    identifier: str
-) -> List[TextContent]:
+# DEPRECATED: Use manage_resource(action="delete") instead
+# @mcp.tool()
+# async def delete_resource(
+#     resource_type: str,
+#     identifier: str
+# ) -> List[TextContent]:
     """
     Delete an indexed resource (repository or documentation).
 
     Args:
         resource_type: Type of resource - "repository" or "documentation"
         identifier:
-            - For repository: Repository in owner/repo format (e.g., "facebook/react")
-            - For documentation: UUID preferred, also supports display name or URL (e.g., "550e8400-e29b-41d4-a716-446655440000", "Vercel AI SDK - Core", or "https://docs.trynia.ai/")
-
-    Returns:
-        Confirmation of deletion
-
-    Examples:
-        - delete_resource("repository", "facebook/react")
-        - delete_resource("documentation", "550e8400-e29b-41d4-a716-446655440000")
-        - delete_resource("documentation", "https://docs.trynia.ai/")
+            - For repos: Repository in owner/repo format (e.g., "facebook/react")
+            - For docs: UUID preferred, also supports display name or URL
     """
     try:
         # Validate resource type
@@ -967,30 +1634,20 @@ async def delete_resource(
             text=f"❌ Error deleting {resource_type}: {str(e)}"
         )]
 
-@mcp.tool()
-async def check_resource_status(
-    resource_type: str,
-    identifier: str
-) -> List[TextContent]:
+# DEPRECATED: Use manage_resource(action="status") instead
+# @mcp.tool()
+# async def check_resource_status(
+#     resource_type: str,
+#     identifier: str
+# ) -> List[TextContent]:
     """
     Check the indexing status of a resource (repository or documentation).
 
     Args:
         resource_type: Type of resource - "repository" or "documentation"
         identifier:
-            - For repository: Repository in owner/repo format (e.g., "facebook/react")
-            - For documentation: Source ID (UUID format only) - use list_resources to get the UUID
-
-    Returns:
-        Current status of the resource
-
-    Examples:
-        - check_resource_status("repository", "facebook/react")
-        - check_resource_status("documentation", "550e8400-e29b-41d4-a716-446655440000")
-
-    Note:
-        - Documentation status checking requires UUID identifiers only
-        - Use list_resources("documentation") to find the UUID for a documentation source
+            - For repos: Repository in owner/repo format 
+            - For docs: Source ID (UUID format only)
     """
     try:
         # Validate resource type
@@ -1081,10 +1738,11 @@ async def check_resource_status(
             text=f"❌ Error checking {resource_type} status: {str(e)}"
         )]
 
-@mcp.tool()
-async def list_resources(
-    resource_type: Optional[str] = None
-) -> List[TextContent]:
+# DEPRECATED: Use manage_resource(action="list") instead
+# @mcp.tool()
+# async def list_resources(
+#     resource_type: Optional[str] = None
+# ) -> List[TextContent]:
     """
     List indexed resources (repositories and/or documentation).
 
@@ -1093,11 +1751,6 @@ async def list_resources(
 
     Returns:
         List of indexed resources with their status
-
-    Examples:
-        - list_resources() - List all resources
-        - list_resources("repository") - List only repositories
-        - list_resources("documentation") - List only documentation
     """
     try:
         # Validate resource type if provided
@@ -1219,9 +1872,6 @@ async def list_resources(
     
     Args:
         source_id: Documentation source ID to delete
-        
-    Returns:
-        Confirmation of deletion
     """
     try:
         client = await ensure_api_client()
@@ -1258,9 +1908,6 @@ async def list_resources(
     
     Args:
         repository: Repository in owner/repo format
-        
-    Returns:
-        Confirmation of deletion
     """
     try:
         client = await ensure_api_client()
@@ -1298,9 +1945,6 @@ async def list_resources(
     Args:
         repository: Repository in owner/repo format
         new_name: New display name for the repository (1-100 characters)
-        
-    Returns:
-        Confirmation of rename operation
     """
     try:
         # Validate name length
@@ -1345,9 +1989,6 @@ async def list_resources(
     Args:
         source_id: Documentation source ID
         new_name: New display name for the documentation (1-100 characters)
-        
-    Returns:
-        Confirmation of rename operation
     """
     try:
         # Validate name length
@@ -1393,30 +2034,14 @@ async def nia_web_search(
     find_similar_to: Optional[str] = None
 ) -> List[TextContent]:
     """
-    Search repositories, documentation, and other content using AI-powered search.
-    Returns results formatted to guide next actions.
-    
-    USE THIS TOOL WHEN:
-    - Finding specific repos/docs/content ("find X library", "trending Y frameworks")
-    - Looking for examples or implementations
-    - Searching for what's available on a topic
-    - Simple, direct searches that need quick results
-    - Finding similar content to a known URL
-    
-    DON'T USE THIS FOR:
-    - Comparative analysis (use nia_deep_research_agent instead)
-    - Complex multi-faceted questions (use nia_deep_research_agent instead)
-    - Questions requiring synthesis of multiple sources (use nia_deep_research_agent instead)
+    Search repositories, documentation, and other content using web search.
     
     Args:
         query: Natural language search query (e.g., "best RAG implementations", "trending rust web frameworks")
         num_results: Number of results to return (default: 5, max: 10)
         category: Filter by category: "github", "company", "research paper", "news", "tweet", "pdf"
         days_back: Only show results from the last N days (for trending content)
-        find_similar_to: URL to find similar content to
-        
-    Returns:
-        Search results with actionable next steps
+        find_similar_to: URL to find similar content
     """
     try:
         client = await ensure_api_client()
@@ -1516,13 +2141,7 @@ async def nia_web_search(
         
         # Add prominent call-to-action if we found indexable content
         if github_repos or documentation:
-            response_text += "\n## 🎯 **Ready to unlock NIA's AI capabilities?**\n"
-            response_text += "The repositories and documentation above can be indexed for:\n"
-            response_text += "- 🤖 AI-powered code understanding and search\n"
-            response_text += "- 💡 Instant answers to technical questions\n"
-            response_text += "- 🔍 Deep architectural insights\n"
-            response_text += "- 📚 Smart documentation Q&A\n\n"
-            response_text += "**Just copy and paste the index commands above!**\n"
+            response_text += "\n## 🎯 **Ready to unlock nia's tools**\n"
         
         # Add search metadata
         response_text += f"\n---\n"
@@ -1562,27 +2181,6 @@ async def nia_deep_research_agent(
 ) -> List[TextContent]:
     """
     Perform deep, multi-step research on a topic using advanced AI research capabilities.
-    Best for complex questions that need comprehensive analysis. Don't just use keywords or unstrctured query, make a comprehensive question to get the best results possible.
-    
-    USE THIS TOOL WHEN:
-    - Comparing multiple options ("compare X vs Y vs Z")
-    - Analyzing pros and cons
-    - Questions with "best", "top", "which is better"
-    - Needing structured analysis or synthesis
-    - Complex questions requiring multiple sources
-    - Questions about trends, patterns, or developments
-    - Requests for comprehensive overviews
-    
-    DON'T USE THIS FOR:
-    - Simple lookups (use nia_web_search instead)
-    - Finding a specific known item (use nia_web_search instead)
-    - Quick searches for repos/docs (use nia_web_search instead)
-    
-    COMPLEXITY INDICATORS:
-    - Words like: compare, analyze, evaluate, pros/cons, trade-offs
-    - Multiple criteria mentioned
-    - Asking for recommendations based on context
-    - Needing structured output (tables, lists, comparisons)
     
     Args:
         query: Research question (e.g., "Compare top 3 RAG frameworks with pros/cons")
@@ -1663,229 +2261,73 @@ async def nia_deep_research_agent(
                 return urls_list
             
             # Extract all URLs from the data
-            all_urls = extract_urls_from_data(result["data"])
-            
-            # Filter for GitHub repos and documentation
-            import re
-            github_pattern = r'github\.com/([a-zA-Z0-9-]+/[a-zA-Z0-9-_.]+)'
-            
-            for url in all_urls:
-                # Check for GitHub repos
-                github_match = re.search(github_pattern, url)
-                if github_match and '/tree/' not in url and '/blob/' not in url:
-                    repos_found.append(github_match.group(1))
-                # Check for documentation URLs
-                elif any(doc_indicator in url.lower() for doc_indicator in ['docs', 'documentation', '.readthedocs.', '/guide', '/tutorial']):
-                    docs_found.append(url)
-            
-            # Remove duplicates and limit results
-            repos_found = list(set(repos_found))[:3]
-            docs_found = list(set(docs_found))[:3]
-            
-            if repos_found:
-                response_text += "**🚀 DISCOVERED REPOSITORIES - Index with NIA for deep analysis:**\n"
-                for repo in repos_found:
-                    response_text += f"```\nIndex {repo}\n```\n"
-                response_text += "✨ Enable AI-powered code search and architecture understanding!\n\n"
-            
-            if docs_found:
-                response_text += "**📖 DISCOVERED DOCUMENTATION - Index with NIA for smart search:**\n"
-                for doc in docs_found[:2]:  # Limit to 2 for readability
-                    response_text += f"```\nIndex documentation {doc}\n```\n"
-                response_text += "✨ Make documentation instantly searchable with AI Q&A!\n\n"
-            
-            if not repos_found and not docs_found:
-                response_text += "**🔍 Manual indexing options:**\n"
-                response_text += "- If you see any GitHub repos mentioned: Say \"Index [owner/repo]\"\n"
-                response_text += "- If you see any documentation sites: Say \"Index documentation [url]\"\n"
-                response_text += "- These will unlock NIA's powerful AI search capabilities!\n\n"
-            
-            response_text += "**📊 Other actions:**\n"
-            response_text += "- Ask follow-up questions about the research\n"
-            response_text += "- Request a different analysis format\n"
-            response_text += "- Search for more specific information\n"
-        else:
-            response_text += "No structured data returned. The research may need a more specific query."
-        
-        return [TextContent(type="text", text=response_text)]
-        
-    except APIError as e:
-        logger.error(f"API Error in deep research: {e}")
-        if e.status_code == 403 or "free tier limit" in str(e).lower() or "indexing operations" in str(e).lower():
-            if e.detail and "3 free indexing operations" in e.detail:
-                return [TextContent(
-                    type="text", 
-                    text=f"❌ {e.detail}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
-                )]
-            else:
-                return [TextContent(
-                    type="text",
-                    text=f"❌ {str(e)}\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
-                )]
-        else:
-            return [TextContent(type="text", text=f"❌ {str(e)}")]
-    except Exception as e:
-        logger.error(f"Error in deep research: {str(e)}")
-        return [TextContent(
-            type="text",
-            text=f"❌ Research error: {str(e)}\n\n"
-                 "Try simplifying your question or using the regular nia_web_search tool."
-        )]
-
-@mcp.tool()
-async def initialize_project(
-    project_root: str,
-    profiles: Optional[List[str]] = None
-) -> List[TextContent]:
-    """
-    Initialize a NIA-enabled project with IDE-specific rules and configurations.
-    
-    This tool sets up your project with NIA integration, creating configuration files
-    and rules tailored to your IDE or editor. It enables AI assistants to better
-    understand and work with NIA's knowledge search capabilities.
-    
-    Args:
-        project_root: Absolute path to the project root directory
-        profiles: List of IDE profiles to set up (default: ["cursor"]). 
-                 Options: cursor, vscode, claude, windsurf, cline, codex, zed, jetbrains, neovim, sublime
-        
-    Returns:
-        Status of the initialization with created files and next steps
-    
-    Examples:
-        - Basic: initialize_project("/path/to/project")
-        - Multiple IDEs: initialize_project("/path/to/project", profiles=["cursor", "vscode"])
-        - Specific IDE: initialize_project("/path/to/project", profiles=["windsurf"])
-    """
-    try:
-        # Validate project root
-        project_path = Path(project_root)
-        if not project_path.is_absolute():
-            return [TextContent(
-                type="text",
-                text=f"❌ Error: project_root must be an absolute path. Got: {project_root}"
-            )]
-        
-        # Default to cursor profile if none specified
-        if profiles is None:
-            profiles = ["cursor"]
-        
-        # Validate profiles
-        supported = get_supported_profiles()
-        invalid_profiles = [p for p in profiles if p not in supported]
-        if invalid_profiles:
-            return [TextContent(
-                type="text",
-                text=f"❌ Unknown profiles: {', '.join(invalid_profiles)}\n\n"
-                     f"Supported profiles: {', '.join(supported)}"
-            )]
-        
-        logger.info(f"Initializing NIA project at {project_root} with profiles: {profiles}")
-        
-        # Initialize the project
-        result = initialize_nia_project(
-            project_root=project_root,
-            profiles=profiles
-        )
-        
-        if not result.get("success"):
-            return [TextContent(
-                type="text",
-                text=f"❌ Failed to initialize project: {result.get('error', 'Unknown error')}"
-            )]
-        
-        # Format success response
-        response_lines = [
-            f"✅ Successfully initialized NIA project at: {project_root}",
-            "",
-            "## 📁 Created Files:",
-        ]
-        
-        for file in result.get("files_created", []):
-            response_lines.append(f"- {file}")
-        
-        if result.get("profiles_initialized"):
-            response_lines.extend([
-                "",
-                "## 🎨 Initialized Profiles:",
-            ])
-            for profile in result["profiles_initialized"]:
-                response_lines.append(f"- {profile}")
-        
-        if result.get("warnings"):
-            response_lines.extend([
-                "",
-                "## ⚠️ Warnings:",
-            ])
-            for warning in result["warnings"]:
-                response_lines.append(f"- {warning}")
-        
-        if result.get("next_steps"):
-            response_lines.extend([
-                "",
-                "## 🚀 Next Steps:",
-            ])
-            for i, step in enumerate(result["next_steps"], 1):
-                response_lines.append(f"{i}. {step}")
-        
-        # Add profile-specific instructions
-        response_lines.extend([
-            "",
-            "## 💡 Quick Start:",
-        ])
-        
-        if "cursor" in profiles:
-            response_lines.extend([
-                "**For Cursor:**",
-                "1. Restart Cursor to load the NIA MCP server",
-                "2. Run `list_repositories` to verify connection",
-                "3. Start indexing with `index_repository https://github.com/owner/repo`",
-                ""
-            ])
-        
-        if "vscode" in profiles:
-            response_lines.extend([
-                "**For VSCode:**",
-                "1. Reload the VSCode window (Cmd/Ctrl+R)",
-                "2. Open command palette (Cmd/Ctrl+Shift+P)",
-                "3. Run 'NIA: Index Repository' task",
-                ""
-            ])
-        
-        if "claude" in profiles:
-            response_lines.extend([
-                "**For Claude Desktop:**",
-                "1. The .claude directory has been created",
-                "2. Claude will now understand NIA commands",
-                "3. Try: 'Search for authentication patterns'",
-                ""
-            ])
-        
-        # Add general tips
-        response_lines.extend([
-            "## 📚 Tips:",
-            "- Use natural language for searches: 'How does X work?'",
-            "- Index repositories before searching them",
-            "- Use `nia_web_search` to discover new repositories",
-            "- Check `list_repositories` to see what's already indexed",
-            "",
-            "Ready to supercharge your development with AI-powered code search! 🚀"
-        ])
+            all_urls = extract_urls_from_data(result["data"])
+            
+            # Filter for GitHub repos and documentation
+            import re
+            github_pattern = r'github\.com/([a-zA-Z0-9-]+/[a-zA-Z0-9-_.]+)'
+            
+            for url in all_urls:
+                # Check for GitHub repos
+                github_match = re.search(github_pattern, url)
+                if github_match and '/tree/' not in url and '/blob/' not in url:
+                    repos_found.append(github_match.group(1))
+                # Check for documentation URLs
+                elif any(doc_indicator in url.lower() for doc_indicator in ['docs', 'documentation', '.readthedocs.', '/guide', '/tutorial']):
+                    docs_found.append(url)
+            
+            # Remove duplicates and limit results
+            repos_found = list(set(repos_found))[:3]
+            docs_found = list(set(docs_found))[:3]
+            
+            if repos_found:
+                response_text += "**🚀 DISCOVERED REPOSITORIES - Index with NIA for deep analysis:**\n"
+                for repo in repos_found:
+                    response_text += f"```\nIndex {repo}\n```\n"
+                response_text += "✨ Enable AI-powered code search and architecture understanding!\n\n"
+            
+            if docs_found:
+                response_text += "**📖 DISCOVERED DOCUMENTATION - Index with NIA for smart search:**\n"
+                for doc in docs_found[:2]:  # Limit to 2 for readability
+                    response_text += f"```\nIndex documentation {doc}\n```\n"
+                response_text += "✨ Make documentation instantly searchable with AI Q&A!\n\n"
+            
+            if not repos_found and not docs_found:
+                response_text += "**🔍 Manual indexing options:**\n"
+                response_text += "- If you see any GitHub repos mentioned: Say \"Index [owner/repo]\"\n"
+                response_text += "- If you see any documentation sites: Say \"Index documentation [url]\"\n"
+                response_text += "- These will unlock NIA's powerful AI search capabilities!\n\n"
+            
+            response_text += "**📊 Other actions:**\n"
+            response_text += "- Ask follow-up questions about the research\n"
+            response_text += "- Request a different analysis format\n"
+            response_text += "- Search for more specific information\n"
+        else:
+            response_text += "No structured data returned. The research may need a more specific query."
         
-        return [TextContent(
-            type="text",
-            text="\n".join(response_lines)
-        )]
+        return [TextContent(type="text", text=response_text)]
         
+    except APIError as e:
+        logger.error(f"API Error in deep research: {e}")
+        if e.status_code == 403 or "free tier limit" in str(e).lower() or "indexing operations" in str(e).lower():
+            if e.detail and "3 free indexing operations" in e.detail:
+                return [TextContent(
+                    type="text", 
+                    text=f"❌ {e.detail}\n\n💡 Tip: Upgrade to Pro at https://trynia.ai/billing for unlimited indexing."
+                )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ {str(e)}\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
+                )]
+        else:
+            return [TextContent(type="text", text=f"❌ {str(e)}")]
     except Exception as e:
-        logger.error(f"Error in initialize_project tool: {e}")
+        logger.error(f"Error in deep research: {str(e)}")
         return [TextContent(
             type="text",
-            text=f"❌ Error initializing project: {str(e)}\n\n"
-                 "Please check:\n"
-                 "- The project_root path is correct and accessible\n"
-                 "- You have write permissions to the directory\n"
-                 "- The NIA MCP server is properly installed"
+            text=f"❌ Research error: {str(e)}\n\n"
+                 "Try simplifying your question or using the regular nia_web_search tool."
         )]
 
 @mcp.tool()
@@ -1897,22 +2339,15 @@ async def read_source_content(
     """
     Read the full content of a specific source file or document.
     
-    This tool allows AI to fetch complete content from sources identified during search,
-    enabling deeper analysis when the truncated search results are insufficient.
-    
     Args:
         source_type: Type of source - "repository" or "documentation"
         source_identifier: 
-            - For repository: "owner/repo:path/to/file.py" (e.g., "facebook/react:src/React.js")
+            - For repository: "owner/repo:path/to/file.py"
             - For documentation: The source URL or document ID
         metadata: Optional metadata from search results to help locate the source
         
     Returns:
         Full content of the requested source with metadata
-        
-    Examples:
-        - read_source_content("repository", "langchain-ai/langchain:libs/core/langchain_core/runnables/base.py")
-        - read_source_content("documentation", "https://docs.python.org/3/library/asyncio.html")
     """
     try:
         client = await ensure_api_client()
@@ -2015,7 +2450,6 @@ async def read_source_content(
             type="text",
             text=f"❌ Error reading source content: {str(e)}"
         )]
-
 # @mcp.tool()
 # async def index_local_filesystem(
 #     directory_path: str,
@@ -2432,6 +2866,7 @@ async def read_source_content(
 #   - npm: Node.js packages from NPM registry
 #   - crates_io: Rust packages from crates.io
 #   - golang_proxy: Go modules from Go proxy
+#   - ruby_gems: Ruby gems from RubyGems.org
 #
 # Authentication:
 #   - Requires CHROMA_API_KEY environment variable
@@ -2467,8 +2902,6 @@ async def nia_package_search_grep(
     Required Args: "registry", "package_name", "pattern" Optional Args: "version", "language",
     "filename_sha256", "a", "b", "c", "head_limit", "output_mode"
 
-    Best for: Deterministic code search, finding specific code patterns, or exploring code structure.
-
     Parameters:
         a: The number of lines after a grep match to include
         b: The number of lines before a grep match to include
@@ -2476,23 +2909,19 @@ async def nia_package_search_grep(
         filename_sha256: The sha256 hash of the file to filter for
         head_limit: Limits number of results returned. If the number of results returned is less than the
             head limit, all results have been returned.
-        language: The languages to filter for. If not provided, all languages will be searched. Valid
-            options: "Rust", "Go", "Python", "JavaScript", "JSX", "TypeScript", "TSX", "HTML", "Markdown",
-            "YAML", "Bash", "SQL", "JSON", "Text", "Dockerfile", "HCL", "Protobuf", "Make", "Toml", "Jupyter Notebook"
+        language: The languages to filter for. If not provided, all languages will be searched.
         output_mode: Controls the shape of the grep output. Accepted values:
             "content" (default): return content snippets with line ranges
             "files_with_matches": return unique files (path and sha256) that match
             "count": return files with the count of matches per file
         package_name: The name of the requested package. Pass the name as it appears in the package
             manager. For Go packages, use the GitHub organization and repository name in the format
-            {org}/{repo}, if unsure check the GitHub URL for the package and use {org}/{repo} from that URL.
+            {org}/{repo}
         pattern: The regex pattern for exact text matching in the codebase. Must be a valid regex.
             Example: "func\\s+\\(get_repository\\|getRepository\\)\\s*\\(.*?\\)\\s\\{"
         registry: The name of the registry containing the requested package. Must be one of:
-            "crates_io", "golang_proxy", "npm", or "py_pi".
-        version: Optionally, the specific version of the package whose source code to search.
-            If provided, must be in semver format: {major}.{minor}.{patch}. Otherwise, the latest indexed
-            version of the package available will be used.
+            "crates_io", "golang_proxy", "npm", "py_pi", or "ruby_gems".
+        version: Optional
     """
     try:
         # Use API client for backend routing
@@ -2604,33 +3033,24 @@ async def nia_package_search_hybrid(
     language: Optional[str] = None
 ) -> List[TextContent]:
     """
-    Searches package source code using semantic understanding AND optionally regex patterns. This
-    allows for hybrid search, allowing for prefiltering with regex, and semantic ranking.
+    Searches package source code using semantic understanding AND optionally regex patterns.
 
     Required Args: "registry", "package_name", "semantic_queries"
 
     Optional Args: "version", "filename_sha256", "pattern", "language"
 
-    Best for: Understanding how packages implement specific features, finding usage patterns, or
-    exploring code structure.
-
     Parameters:
         filename_sha256: The sha256 hash of the file to filter for
-        language: The languages to filter for. If not provided, all languages will be searched. Valid
-            options: "Rust", "Go", "Python", "JavaScript", "JSX", "TypeScript", "TSX", "HTML", "Markdown",
-            "YAML", "Bash", "SQL", "JSON", "Text", "Dockerfile", "HCL", "Protobuf", "Make", "Toml", "Jupyter Notebook"
-        package_name: The name of the requested package. Pass the name as it appears in the package
-            manager. For Go packages, use the GitHub organization and repository name in the format
-            {org}/{repo}, if unsure check the GitHub URL for the package and use {org}/{repo} from that URL.
+        language: The languages to filter for. If not provided, all languages will be searched.
+        package_name: The name of the requested package. Pass the name as it appears in the package manager. For Go packages, use the GitHub organization and repository name in the format
+            {org}/{repo}
         pattern: The regex pattern for exact text matching in the codebase. Must be a valid regex.
             Example: "func\\s+\\(get_repository\\|getRepository\\)\\s*\\(.*?\\)\\s\\{"
         registry: The name of the registry containing the requested package. Must be one of:
-            "crates_io", "golang_proxy", "npm", or "py_pi".
+            "crates_io", "golang_proxy", "npm", "py_pi", or "ruby_gems".
         semantic_queries: Array of 1-5 plain English questions about the codebase. Example: ["how is
             argmax implemented in numpy?", "what testing patterns does axum use?"]
-        version: Optionally, the specific version of the package whose source code to search.
-            If provided, must be in semver format: {major}.{minor}.{patch}. Otherwise, the latest indexed
-            version of the package available will be used.
+        version: Optional
     """
     try:
         # Use API client for backend routing
@@ -2748,21 +3168,16 @@ async def nia_package_search_read_file(
     Required Args: "registry", "package_name", "filename_sha256", "start_line", "end_line" Optional Args:
     "version"
 
-    Best for: Inspecting exact code snippets when you already know the file and line numbers. Max 200
-    lines.
-
     Parameters:
         end_line: 1-based inclusive end line to read
         filename_sha256: The sha256 hash of the file to filter for
         package_name: The name of the requested package. Pass the name as it appears in the package
             manager. For Go packages, use the GitHub organization and repository name in the format
-            {org}/{repo}, if unsure check the GitHub URL for the package and use {org}/{repo} from that URL.
+            {org}/{repo}
         registry: The name of the registry containing the requested package. Must be one of:
-            "crates_io", "golang_proxy", "npm", or "py_pi".
+            "crates_io", "golang_proxy", "npm", "py_pi", or "ruby_gems".
         start_line: 1-based inclusive start line to read
-        version: Optionally, the specific version of the package whose source code to search.
-            If provided, must be in semver format: {major}.{minor}.{patch}. Otherwise, the latest indexed
-            version of the package available will be used.
+        version: Optional
     """
     try:
         # Validate line range
@@ -2833,24 +3248,11 @@ async def nia_bug_report(
     additional_context: Optional[str] = None
 ) -> List[TextContent]:
     """
-    Submit a bug report or feature request to the Nia development team.
-
-    This tool allows users to report bugs, request features, or provide feedback
-    directly to the development team. Reports are sent via email and Slack for
-    immediate attention.
-
+    Submit a bug report or feature request.
     Args:
         description: Detailed description of the bug or feature request (10-5000 characters)
         bug_type: Type of report - "bug", "feature-request", "improvement", or "other" (default: "bug")
         additional_context: Optional additional context, steps to reproduce, or related information
-
-    Returns:
-        Confirmation of successful submission with reference ID
-
-    Examples:
-        - nia_bug_report("The search is not returning any results for my repository")
-        - nia_bug_report("Add support for searching within specific file types", "feature-request")
-        - nia_bug_report("Repository indexing fails with large repos", "bug", "Happens with repos over 1GB")
     """
     try:
         client = await ensure_api_client()
@@ -2934,28 +3336,553 @@ async def nia_bug_report(
 # Context Sharing Tools
 
 @mcp.tool()
-async def save_context(
-    title: str,
-    summary: str,
-    content: str,
-    agent_source: str,
+async def context(
+    action: str,
+    # For save action
+    title: Optional[str] = None,
+    summary: Optional[str] = None,
+    content: Optional[str] = None,
+    agent_source: Optional[str] = None,
     tags: Optional[List[str]] = None,
     metadata: Optional[dict] = None,
     nia_references: Optional[dict] = None,
-    edited_files: Optional[List[dict]] = None
+    edited_files: Optional[List[dict]] = None,
+    # For list/search actions
+    limit: int = 20,
+    offset: int = 0,
+    # For retrieve/update/delete actions
+    context_id: Optional[str] = None,
+    # For search action
+    query: Optional[str] = None
 ) -> List[TextContent]:
     """
-    Save a conversation context for cross-agent sharing.
+    Unified context management tool for saving, listing, retrieving, searching, updating, and deleting conversation contexts.
+
+    Args:
+        action: Action to perform - "save", "list", "retrieve", "search", "update", or "delete"
+
+        # Save action parameters (all required except tags, metadata, nia_references, edited_files):
+        title: Descriptive title for the context
+        summary: Brief summary of the conversation (10-1000 chars)
+        content: Full conversation context (minimum 50 chars)
+        agent_source: Which agent is creating this context (e.g., "cursor", "claude-code")
+        tags: Optional list of searchable tags
+        metadata: Optional metadata like file paths, repositories discussed, etc.
+        nia_references: Structured data about NIA resources used during conversation
+        edited_files: List of files that were modified during conversation
+
+        # List action parameters (all optional):
+        limit: Number of contexts to return (1-100, default: 20)
+        offset: Number of contexts to skip for pagination (default: 0)
+
+        # Retrieve action parameters:
+        context_id: The unique ID of the context to retrieve (required)
+
+        # Search action parameters:
+        query: Search query to match against title, summary, content, and tags (required)
+        limit: Maximum number of results to return (1-100, default: 20)
+
+        # Update action parameters:
+        context_id: The unique ID of the context to update (required)
+        title: Updated title (optional)
+        summary: Updated summary (optional)
+        content: Updated content (optional)
+        tags: Updated tags list (optional)
+        metadata: Updated metadata (optional)
+
+        # Delete action parameters:
+        context_id: The unique ID of the context to delete (required)
+
+    Examples:
+        # Save context
+        context(action="save", title="API Design", summary="Discussed REST patterns",
+                content="Full conversation...", agent_source="cursor")
+
+        # List contexts
+        context(action="list", limit=10, agent_source="cursor")
+
+        # Retrieve context
+        context(action="retrieve", context_id="550e8400-e29b-41d4-a716-446655440000")
+
+        # Search contexts
+        context(action="search", query="authentication", limit=10)
+
+        # Update context
+        context(action="update", context_id="550e8400...", title="New Title", tags=["updated"])
+
+        # Delete context
+        context(action="delete", context_id="550e8400-e29b-41d4-a716-446655440000")
+    """
+    try:
+        # Validate action
+        valid_actions = ["save", "list", "retrieve", "search", "update", "delete"]
+        if action not in valid_actions:
+            return [TextContent(
+                type="text",
+                text=f"❌ Invalid action: '{action}'. Must be one of: {', '.join(valid_actions)}"
+            )]
+
+        client = await ensure_api_client()
+
+        # ===== SAVE ACTION =====
+        if action == "save":
+            # Validate required parameters
+            if not title or not title.strip():
+                return [TextContent(type="text", text="❌ Error: title is required for save action")]
+            if not summary:
+                return [TextContent(type="text", text="❌ Error: summary is required for save action")]
+            if not content:
+                return [TextContent(type="text", text="❌ Error: content is required for save action")]
+            if not agent_source or not agent_source.strip():
+                return [TextContent(type="text", text="❌ Error: agent_source is required for save action")]
+
+            # Validate field lengths
+            if len(title) > 200:
+                return [TextContent(type="text", text="❌ Error: Title must be 200 characters or less")]
+            if len(summary) < 10 or len(summary) > 1000:
+                return [TextContent(type="text", text="❌ Error: Summary must be 10-1000 characters")]
+            if len(content) < 50:
+                return [TextContent(type="text", text="❌ Error: Content must be at least 50 characters")]
+
+            logger.info(f"Saving context: title='{title}', agent={agent_source}, content_length={len(content)}")
+
+            result = await client.save_context(
+                title=title.strip(),
+                summary=summary.strip(),
+                content=content,
+                agent_source=agent_source.strip(),
+                tags=tags or [],
+                metadata=metadata or {},
+                nia_references=nia_references,
+                edited_files=edited_files or []
+            )
+
+            context_id_result = result.get("id")
+
+            return [TextContent(
+                type="text",
+                text=f"✅ **Context Saved Successfully!**\n\n"
+                     f"🆔 **Context ID:** `{context_id_result}`\n"
+                     f"📝 **Title:** {title}\n"
+                     f"🤖 **Source Agent:** {agent_source}\n"
+                     f"📊 **Content Length:** {len(content):,} characters\n"
+                     f"🏷️ **Tags:** {', '.join(tags) if tags else 'None'}\n\n"
+                     f"**Next Steps:**\n"
+                     f"• Other agents can now retrieve this context using the context ID\n"
+                     f"• Use `context(action='search', query='...')` to find contexts\n"
+                     f"• Use `context(action='list')` to see all your saved contexts\n\n"
+                     f"🔗 **Share this context:** Provide the context ID `{context_id_result}` to other agents"
+            )]
+
+        # ===== LIST ACTION =====
+        elif action == "list":
+            # Validate parameters
+            if limit < 1 or limit > 100:
+                return [TextContent(type="text", text="❌ Error: Limit must be between 1 and 100")]
+            if offset < 0:
+                return [TextContent(type="text", text="❌ Error: Offset must be 0 or greater")]
+
+            # Convert tags list to comma-separated string if provided
+            tags_filter = ','.join(tags) if tags and isinstance(tags, list) else (tags if isinstance(tags, str) else None)
+
+            result = await client.list_contexts(
+                limit=limit,
+                offset=offset,
+                tags=tags_filter,
+                agent_source=agent_source
+            )
+
+            contexts = result.get("contexts", [])
+            pagination = result.get("pagination", {})
+
+            if not contexts:
+                response = "📭 **No Contexts Found**\n\n"
+                if tags or agent_source:
+                    response += "No contexts match your filters.\n\n"
+                else:
+                    response += "You haven't saved any contexts yet.\n\n"
+
+                response += "**Get started:**\n"
+                response += "• Use `context(action='save', ...)` to save a conversation for cross-agent sharing\n"
+                response += "• Perfect for handoffs between Cursor and Claude Code!"
+
+                return [TextContent(type="text", text=response)]
+
+            # Format the response
+            response = f"📚 **Your Conversation Contexts** ({pagination.get('total', len(contexts))} total)\n\n"
+
+            for i, ctx in enumerate(contexts, offset + 1):
+                created_at = ctx.get('created_at', '')
+                if created_at:
+                    try:
+                        from datetime import datetime
+                        dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                        formatted_date = dt.strftime('%Y-%m-%d %H:%M UTC')
+                    except:
+                        formatted_date = created_at
+                else:
+                    formatted_date = 'Unknown'
+
+                response += f"**{i}. {ctx['title']}**\n"
+                response += f"   🆔 ID: `{ctx['id']}`\n"
+                response += f"   🤖 Source: {ctx['agent_source']}\n"
+                response += f"   📅 Created: {formatted_date}\n"
+                response += f"   📝 Summary: {ctx['summary'][:100]}{'...' if len(ctx['summary']) > 100 else ''}\n"
+                if ctx.get('tags'):
+                    response += f"   🏷️ Tags: {', '.join(ctx['tags'])}\n"
+                response += "\n"
+
+            # Add pagination info
+            if pagination.get('has_more'):
+                next_offset = offset + limit
+                response += f"📄 **Pagination:** Showing {offset + 1}-{offset + len(contexts)} of {pagination.get('total')}\n"
+                response += f"   Use `context(action='list', offset={next_offset})` for next page\n"
+
+            response += "\n**Actions:**\n"
+            response += "• `context(action='retrieve', context_id='...')` - Get full context\n"
+            response += "• `context(action='search', query='...')` - Search contexts\n"
+            response += "• `context(action='delete', context_id='...')` - Remove context"
+
+            return [TextContent(type="text", text=response)]
+
+        # ===== RETRIEVE ACTION =====
+        elif action == "retrieve":
+            if not context_id or not context_id.strip():
+                return [TextContent(type="text", text="❌ Error: context_id is required for retrieve action")]
+
+            ctx = await client.get_context(context_id.strip())
+
+            if not ctx:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ **Context Not Found**\n\n"
+                         f"Context ID `{context_id}` was not found.\n\n"
+                         f"**Possible reasons:**\n"
+                         f"• The context ID is incorrect\n"
+                         f"• The context belongs to a different user\n"
+                         f"• The context has been deleted\n\n"
+                         f"Use `context(action='list')` to see your available contexts."
+                )]
+
+            # Format the context display
+            created_at = ctx.get('created_at', '')
+            if created_at:
+                try:
+                    from datetime import datetime
+                    dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                    formatted_date = dt.strftime('%Y-%m-%d %H:%M UTC')
+                except:
+                    formatted_date = created_at
+            else:
+                formatted_date = 'Unknown'
+
+            updated_at = ctx.get('updated_at', '')
+            formatted_updated = None
+            if updated_at:
+                try:
+                    from datetime import datetime
+                    dt = datetime.fromisoformat(updated_at.replace('Z', '+00:00'))
+                    formatted_updated = dt.strftime('%Y-%m-%d %H:%M UTC')
+                except:
+                    formatted_updated = updated_at
+
+            response = f"📋 **Context: {ctx['title']}**\n\n"
+            response += f"🆔 **ID:** `{ctx['id']}`\n"
+            response += f"🤖 **Source Agent:** {ctx['agent_source']}\n"
+            response += f"📅 **Created:** {formatted_date}\n"
+            if formatted_updated:
+                response += f"🔄 **Updated:** {formatted_updated}\n"
+
+            if ctx.get('tags'):
+                response += f"🏷️ **Tags:** {', '.join(ctx['tags'])}\n"
+
+            response += f"\n📝 **Summary:**\n{ctx['summary']}\n\n"
+
+            # Add NIA References
+            nia_refs = ctx.get('nia_references') or {}
+            if nia_refs:
+                response += "🧠 **NIA RESOURCES USED - RECOMMENDED ACTIONS:**\n"
+
+                indexed_resources = nia_refs.get('indexed_resources', [])
+                if indexed_resources:
+                    response += "**📦 Re-index these resources:**\n"
+                    for resource in indexed_resources:
+                        identifier = resource.get('identifier', 'Unknown')
+                        resource_type = resource.get('resource_type', 'unknown')
+                        purpose = resource.get('purpose', 'No purpose specified')
+
+                        if resource_type == 'repository':
+                            response += f"• `Index {identifier}` - {purpose}\n"
+                        elif resource_type == 'documentation':
+                            response += f"• `Index documentation {identifier}` - {purpose}\n"
+                        else:
+                            response += f"• `Index {identifier}` ({resource_type}) - {purpose}\n"
+                    response += "\n"
+
+                search_queries = nia_refs.get('search_queries', [])
+                if search_queries:
+                    response += "**🔍 Useful search queries to re-run:**\n"
+                    for q in search_queries:
+                        query_text = q.get('query', 'Unknown query')
+                        query_type = q.get('query_type', 'search')
+                        key_findings = q.get('key_findings', 'No findings specified')
+                        resources_searched = q.get('resources_searched', [])
+
+                        response += f"• **Query:** `{query_text}` ({query_type})\n"
+                        if resources_searched:
+                            response += f"  **Resources:** {', '.join(resources_searched)}\n"
+                        response += f"  **Key Findings:** {key_findings}\n"
+                    response += "\n"
+
+                session_summary = nia_refs.get('session_summary')
+                if session_summary:
+                    response += f"**📋 NIA Session Summary:** {session_summary}\n\n"
+
+            # Add Edited Files
+            edited_files_list = ctx.get('edited_files') or []
+            if edited_files_list:
+                response += "📝 **FILES MODIFIED - READ THESE TO GET UP TO SPEED:**\n"
+                for file_info in edited_files_list:
+                    file_path = file_info.get('file_path', 'Unknown file')
+                    operation = file_info.get('operation', 'modified')
+                    changes_desc = file_info.get('changes_description', 'No description')
+                    key_changes = file_info.get('key_changes', [])
+                    language = file_info.get('language', '')
+
+                    operation_emoji = {
+                        'created': '🆕',
+                        'modified': '✏️',
+                        'deleted': '🗑️'
+                    }.get(operation, '📄')
+
+                    response += f"• {operation_emoji} **`{file_path}`** ({operation})\n"
+                    response += f"  **Changes:** {changes_desc}\n"
+
+                    if key_changes:
+                        response += f"  **Key Changes:** {', '.join(key_changes)}\n"
+                    if language:
+                        response += f"  **Language:** {language}\n"
+
+                    response += f"  **💡 Action:** Read this file with: `Read {file_path}`\n"
+                response += "\n"
+
+            # Add metadata if available
+            metadata_dict = ctx.get('metadata') or {}
+            if metadata_dict:
+                response += f"📊 **Additional Metadata:**\n"
+                for key, value in metadata_dict.items():
+                    if isinstance(value, list):
+                        response += f"• **{key}:** {', '.join(map(str, value))}\n"
+                    else:
+                        response += f"• **{key}:** {value}\n"
+                response += "\n"
+
+            response += f"📄 **Full Context:**\n\n{ctx['content']}\n\n"
+
+            response += f"---\n"
+            response += f"🚀 **NEXT STEPS FOR SEAMLESS HANDOFF:**\n"
+            response += f"• This context was created by **{ctx['agent_source']}**\n"
+
+            if nia_refs.get('search_queries'):
+                response += f"• **RECOMMENDED:** Re-run the search queries to get the same insights\n"
+            if edited_files_list:
+                response += f"• **ESSENTIAL:** Read the modified files above to understand code changes\n"
+
+            response += f"• Use the summary and full context to understand the strategic planning\n"
+
+            return [TextContent(type="text", text=response)]
+
+        # ===== SEARCH ACTION =====
+        elif action == "search":
+            if not query or not query.strip():
+                return [TextContent(type="text", text="❌ Error: query is required for search action")]
+
+            if limit < 1 or limit > 100:
+                return [TextContent(type="text", text="❌ Error: Limit must be between 1 and 100")]
+
+            # Convert tags list to comma-separated string if provided
+            tags_filter = ','.join(tags) if tags and isinstance(tags, list) else (tags if isinstance(tags, str) else None)
+
+            result = await client.search_contexts(
+                query=query.strip(),
+                limit=limit,
+                tags=tags_filter,
+                agent_source=agent_source
+            )
+
+            contexts = result.get("contexts", [])
+
+            if not contexts:
+                response = f"🔍 **No Results Found**\n\n"
+                response += f"No contexts match your search query: \"{query}\"\n\n"
+
+                if tags or agent_source:
+                    response += f"**Active filters:**\n"
+                    if tags:
+                        response += f"• Tags: {tags if isinstance(tags, str) else ', '.join(tags)}\n"
+                    if agent_source:
+                        response += f"• Agent: {agent_source}\n"
+                    response += "\n"
+
+                response += f"**Suggestions:**\n"
+                response += f"• Try different keywords\n"
+                response += f"• Remove filters to broaden search\n"
+                response += f"• Use `context(action='list')` to see all contexts"
+
+                return [TextContent(type="text", text=response)]
+
+            # Format search results
+            response = f"🔍 **Search Results for \"{query}\"** ({len(contexts)} found)\n\n"
+
+            for i, ctx in enumerate(contexts, 1):
+                created_at = ctx.get('created_at', '')
+                if created_at:
+                    try:
+                        from datetime import datetime
+                        dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                        formatted_date = dt.strftime('%Y-%m-%d %H:%M UTC')
+                    except:
+                        formatted_date = created_at
+                else:
+                    formatted_date = 'Unknown'
+
+                response += f"**{i}. {ctx['title']}**\n"
+                response += f"   🆔 ID: `{ctx['id']}`\n"
+                response += f"   🤖 Source: {ctx['agent_source']}\n"
+                response += f"   📅 Created: {formatted_date}\n"
+                response += f"   📝 Summary: {ctx['summary'][:150]}{'...' if len(ctx['summary']) > 150 else ''}\n"
+
+                if ctx.get('tags'):
+                    response += f"   🏷️ Tags: {', '.join(ctx['tags'])}\n"
+
+                response += "\n"
+
+            response += f"**Actions:**\n"
+            response += f"• `context(action='retrieve', context_id='...')` - Get full context\n"
+            response += f"• Refine search with different keywords\n"
+            response += f"• Use tags or agent filters for better results"
+
+            return [TextContent(type="text", text=response)]
+
+        # ===== UPDATE ACTION =====
+        elif action == "update":
+            if not context_id or not context_id.strip():
+                return [TextContent(type="text", text="❌ Error: context_id is required for update action")]
+
+            # Check that at least one field is being updated
+            if not any([title, summary, content, tags is not None, metadata is not None]):
+                return [TextContent(
+                    type="text",
+                    text="❌ Error: At least one field must be provided for update (title, summary, content, tags, or metadata)"
+                )]
+
+            # Validate fields if provided
+            if title is not None and (not title.strip() or len(title) > 200):
+                return [TextContent(type="text", text="❌ Error: Title must be 1-200 characters")]
+
+            if summary is not None and (len(summary) < 10 or len(summary) > 1000):
+                return [TextContent(type="text", text="❌ Error: Summary must be 10-1000 characters")]
+
+            if content is not None and len(content) < 50:
+                return [TextContent(type="text", text="❌ Error: Content must be at least 50 characters")]
+
+            if tags is not None and len(tags) > 10:
+                return [TextContent(type="text", text="❌ Error: Maximum 10 tags allowed")]
 
-    This tool enables agents to save conversation contexts that can be shared
-    with other AI agents, creating seamless handoffs between different coding
-    environments (e.g., Cursor → Claude Code).
+            result = await client.update_context(
+                context_id=context_id.strip(),
+                title=title.strip() if title else None,
+                summary=summary.strip() if summary else None,
+                content=content,
+                tags=tags,
+                metadata=metadata
+            )
+
+            if not result:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Error: Context with ID `{context_id}` not found"
+                )]
+
+            # List updated fields
+            updated_fields = []
+            if title is not None:
+                updated_fields.append("title")
+            if summary is not None:
+                updated_fields.append("summary")
+            if content is not None:
+                updated_fields.append("content")
+            if tags is not None:
+                updated_fields.append("tags")
+            if metadata is not None:
+                updated_fields.append("metadata")
+
+            response = f"✅ **Context Updated Successfully!**\n\n"
+            response += f"🆔 **Context ID:** `{context_id}`\n"
+            response += f"📝 **Title:** {result['title']}\n"
+            response += f"🔄 **Updated Fields:** {', '.join(updated_fields)}\n"
+            response += f"🤖 **Source Agent:** {result['agent_source']}\n\n"
+
+            response += f"**Current Status:**\n"
+            response += f"• **Tags:** {', '.join(result['tags']) if result.get('tags') else 'None'}\n"
+            response += f"• **Content Length:** {len(result['content']):,} characters\n\n"
+
+            response += f"Use `context(action='retrieve', context_id='{context_id}')` to see the full updated context."
+
+            return [TextContent(type="text", text=response)]
+
+        # ===== DELETE ACTION =====
+        elif action == "delete":
+            if not context_id or not context_id.strip():
+                return [TextContent(type="text", text="❌ Error: context_id is required for delete action")]
+
+            success = await client.delete_context(context_id.strip())
+
+            if success:
+                return [TextContent(
+                    type="text",
+                    text=f"✅ **Context Deleted Successfully!**\n\n"
+                         f"🆔 **Context ID:** `{context_id}`\n\n"
+                         f"The context has been permanently removed from your account.\n"
+                         f"This action cannot be undone.\n\n"
+                         f"Use `context(action='list')` to see your remaining contexts."
+                )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ **Context Not Found**\n\n"
+                         f"Context ID `{context_id}` was not found or has already been deleted.\n\n"
+                         f"Use `context(action='list')` to see your available contexts."
+                )]
+
+    except APIError as e:
+        logger.error(f"API Error in context ({action}): {e}")
+        return [TextContent(type="text", text=f"❌ API Error: {str(e)}")]
+    except Exception as e:
+        logger.error(f"Error in context ({action}): {e}")
+        return [TextContent(type="text", text=f"❌ Error in {action} operation: {str(e)}")]
+
+# DEPRECATED: Individual context tools below - use context() with action parameter instead
+
+# @mcp.tool()
+# async def save_context(
+#     title: str,
+#     summary: str,
+#     content: str,
+#     agent_source: str,
+#     tags: Optional[List[str]] = None,
+#     metadata: Optional[dict] = None,
+#     nia_references: Optional[dict] = None,
+#     edited_files: Optional[List[dict]] = None
+# ) -> List[TextContent]:
+    """
+    Save a conversation context for cross-agent sharing.
 
     Args:
-        title: A descriptive title for the context (1-200 characters)
-        summary: Brief summary of the conversation (10-1000 characters)
+        title: A descriptive title for the context
+        summary: Brief summary of the conversation
         content: Full conversation context - the agent should compact the conversation history but keep all important parts togethers, as well as code snippets. No excuses.
-        agent_source: Which agent is creating this context (e.g., "cursor", "claude-code", "windsurf")
+        agent_source: Which agent is creating this context (e.g., "cursor")
         tags: Optional list of searchable tags
         metadata: Optional metadata like file paths, repositories discussed, etc.
         nia_references: Structured data about NIA resources used during conversation
@@ -2969,20 +3896,6 @@ async def save_context(
 
     Returns:
         Confirmation of successful context save with context ID
-
-    Example:
-        save_context(
-            title="Streaming AI SDK Implementation",
-            summary="Planning conversation about implementing streaming responses with AI SDK",
-            content="User asked about implementing streaming... [agent should include conversation]",
-            agent_source="cursor",
-            tags=["streaming", "ai-sdk", "implementation"],
-            nia_references={
-                "indexed_resources": [{"identifier": "vercel/ai", "resource_type": "repository", "purpose": "Reference for streaming implementation"}],
-                "search_queries": [{"query": "streaming API", "query_type": "documentation", "key_findings": "Found useChat hook with streaming"}]
-            },
-            edited_files=[{"file_path": "src/chat.ts", "operation": "created", "changes_description": "Added streaming chat component"}]
-        )
     """
     try:
         # Validate input parameters
@@ -3043,13 +3956,14 @@ async def save_context(
         logger.error(f"Error saving context: {e}")
         return [TextContent(type="text", text=f"❌ Error saving context: {str(e)}")]
 
-@mcp.tool()
-async def list_contexts(
-    limit: int = 20,
-    offset: int = 0,
-    tags: Optional[str] = None,
-    agent_source: Optional[str] = None
-) -> List[TextContent]:
+# DEPRECATED: Use context(action="list") instead
+# @mcp.tool()
+# async def list_contexts(
+#     limit: int = 20,
+#     offset: int = 0,
+#     tags: Optional[str] = None,
+#     agent_source: Optional[str] = None
+# ) -> List[TextContent]:
     """
     List saved conversation contexts with pagination and filtering.
 
@@ -3061,12 +3975,6 @@ async def list_contexts(
 
     Returns:
         List of conversation contexts with pagination info
-
-    Examples:
-        - list_contexts() - List recent 20 contexts
-        - list_contexts(limit=50) - List recent 50 contexts
-        - list_contexts(tags="streaming,ai-sdk") - Filter by tags
-        - list_contexts(agent_source="cursor") - Only contexts from Cursor
     """
     try:
         # Validate parameters
@@ -3146,8 +4054,9 @@ async def list_contexts(
         logger.error(f"Error listing contexts: {e}")
         return [TextContent(type="text", text=f"❌ Error listing contexts: {str(e)}")]
 
-@mcp.tool()
-async def retrieve_context(context_id: str) -> List[TextContent]:
+# DEPRECATED: Use context(action="retrieve") instead
+# @mcp.tool()
+# async def retrieve_context(context_id: str) -> List[TextContent]:
     """
     Retrieve a specific conversation context by ID.
 
@@ -3323,19 +4232,17 @@ async def retrieve_context(context_id: str) -> List[TextContent]:
         logger.error(f"Error retrieving context: {e}")
         return [TextContent(type="text", text=f"❌ Error retrieving context: {str(e)}")]
 
-@mcp.tool()
-async def search_contexts(
-    query: str,
-    limit: int = 20,
-    tags: Optional[str] = None,
-    agent_source: Optional[str] = None
-) -> List[TextContent]:
+# DEPRECATED: Use context(action="search") instead
+# @mcp.tool()
+# async def search_contexts(
+#     query: str,
+#     limit: int = 20,
+#     tags: Optional[str] = None,
+#     agent_source: Optional[str] = None
+# ) -> List[TextContent]:
     """
     Search conversation contexts by content, title, or summary.
 
-    Perfect for finding relevant contexts when you remember part of the
-    conversation but not the exact context ID.
-
     Args:
         query: Search query to match against title, summary, content, and tags
         limit: Maximum number of results to return (1-100, default: 20)
@@ -3344,11 +4251,6 @@ async def search_contexts(
 
     Returns:
         Search results with matching contexts
-
-    Examples:
-        - search_contexts("streaming AI SDK")
-        - search_contexts("authentication", tags="security,implementation")
-        - search_contexts("database", agent_source="cursor")
     """
     try:
         # Validate parameters
@@ -3428,15 +4330,16 @@ async def search_contexts(
         logger.error(f"Error searching contexts: {e}")
         return [TextContent(type="text", text=f"❌ Error searching contexts: {str(e)}")]
 
-@mcp.tool()
-async def update_context(
-    context_id: str,
-    title: Optional[str] = None,
-    summary: Optional[str] = None,
-    content: Optional[str] = None,
-    tags: Optional[List[str]] = None,
-    metadata: Optional[dict] = None
-) -> List[TextContent]:
+# DEPRECATED: Use context(action="update") instead
+# @mcp.tool()
+# async def update_context(
+#     context_id: str,
+#     title: Optional[str] = None,
+#     summary: Optional[str] = None,
+#     content: Optional[str] = None,
+#     tags: Optional[List[str]] = None,
+#     metadata: Optional[dict] = None
+# ) -> List[TextContent]:
     """
     Update an existing conversation context.
 
@@ -3450,13 +4353,6 @@ async def update_context(
 
     Returns:
         Confirmation of successful update
-
-    Example:
-        update_context(
-            context_id="550e8400-e29b-41d4-a716-446655440000",
-            title="Updated: Streaming AI SDK Implementation",
-            tags=["streaming", "ai-sdk", "completed"]
-        )
     """
     try:
         if not context_id or not context_id.strip():
@@ -3545,8 +4441,9 @@ async def update_context(
         logger.error(f"Error updating context: {e}")
         return [TextContent(type="text", text=f"❌ Error updating context: {str(e)}")]
 
-@mcp.tool()
-async def delete_context(context_id: str) -> List[TextContent]:
+# DEPRECATED: Use context(action="delete") instead
+# @mcp.tool()
+# async def delete_context(context_id: str) -> List[TextContent]:
     """
     Delete a conversation context.