noverload-mcp 0.6.0 → 0.7.0

package/dist/tools/index-old.js

@@ -0,0 +1,2176 @@
+import { z } from "zod";
+import { generateLLMInstructions, planQueryStrategy, estimateTokenUsage } from "../llm-instructions.js";
+export const tools = [
+    {
+        name: "list_saved_content",
+        description: "List saved content from Noverload with full details including titles, summaries, and insights. Optionally filter by status or content type.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["pending", "processing", "completed", "failed"],
+                    description: "Filter by processing status",
+                },
+                contentType: {
+                    type: "string",
+                    enum: ["youtube", "x_twitter", "reddit", "article", "pdf"],
+                    description: "Filter by content type",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of items to return",
+                    default: 20,
+                },
+            },
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                status: z.enum(["pending", "processing", "completed", "failed"]).optional(),
+                contentType: z.enum(["youtube", "x_twitter", "reddit", "article", "pdf"]).optional(),
+                limit: z.number().optional().default(20),
+            });
+            const params = schema.parse(args);
+            const content = await client.listContent(params);
+            // Build detailed response
+            let responseText = `# Saved Content Library\n`;
+            responseText += `Found ${content.length} items`;
+            const filters = [];
+            if (params.status)
+                filters.push(`status: ${params.status}`);
+            if (params.contentType)
+                filters.push(`type: ${params.contentType}`);
+            if (filters.length > 0) {
+                responseText += ` (filtered by ${filters.join(', ')})`;
+            }
+            responseText += `\n\n`;
+            if (content.length > 0) {
+                content.forEach((item, idx) => {
+                    responseText += `## ${idx + 1}. ${item.title || 'Untitled'}\n`;
+                    responseText += `**ID:** ${item.id}\n`;
+                    responseText += `**Type:** ${item.contentType} | **Status:** ${item.status}`;
+                    if (item.tokenCount) {
+                        responseText += ` | **Size:** ${item.tokenCount.toLocaleString()} tokens`;
+                        if (item.tokenCount > 50000) {
+                            responseText += ` 🚨`;
+                        }
+                        else if (item.tokenCount > 10000) {
+                            responseText += ` ⚠️`;
+                        }
+                    }
+                    responseText += `\n**URL:** ${item.url}\n`;
+                    if (item.summary) {
+                        const summaryObj = typeof item.summary === 'string'
+                            ? { text: item.summary }
+                            : item.summary;
+                        if (summaryObj.one_sentence) {
+                            responseText += `**Summary:** ${summaryObj.one_sentence}\n`;
+                        }
+                    }
+                    responseText += `**Saved:** ${new Date(item.createdAt).toLocaleDateString()}\n`;
+                    responseText += '\n---\n\n';
+                });
+            }
+            else {
+                responseText += "No content found matching the specified filters.";
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: content,
+            };
+        },
+    },
+    {
+        name: "get_content_details",
+        description: "Get complete details about a specific saved content item including full transcript/article text, AI-generated summary, key insights, and all metadata",
+        inputSchema: {
+            type: "object",
+            properties: {
+                contentId: {
+                    type: "string",
+                    description: "The ID of the content to retrieve",
+                },
+            },
+            required: ["contentId"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                contentId: z.string(),
+            });
+            const { contentId } = schema.parse(args);
+            const content = await client.getContent(contentId);
+            // Build comprehensive response with all details
+            let responseText = `# Content Details: ${content.title || 'Untitled'}\n\n`;
+            responseText += `**ID:** ${content.id}\n`;
+            responseText += `**Type:** ${content.contentType}\n`;
+            responseText += `**Status:** ${content.status}\n`;
+            responseText += `**URL:** ${content.url}\n`;
+            responseText += `**Saved:** ${new Date(content.createdAt).toLocaleDateString()}\n`;
+            // Show content size information
+            if (content.tokenCount) {
+                responseText += `**Full Content Size:** ${content.tokenCount.toLocaleString()} tokens`;
+                if (content.tokenCount > 50000) {
+                    responseText += ` 🚨 EXTREMELY LARGE`;
+                }
+                else if (content.tokenCount > 10000) {
+                    responseText += ` ⚠️ LARGE`;
+                }
+                responseText += '\n';
+            }
+            if (content.tags && content.tags.length > 0) {
+                responseText += `**Tags:** ${content.tags.join(', ')}\n`;
+            }
+            responseText += '\n## Summary & Insights\n';
+            if (content.summary) {
+                const summaryObj = typeof content.summary === 'string'
+                    ? { text: content.summary }
+                    : content.summary;
+                if (summaryObj.one_sentence) {
+                    responseText += `**One-line Summary:** ${summaryObj.one_sentence}\n\n`;
+                }
+                if (summaryObj.key_insights && Array.isArray(summaryObj.key_insights)) {
+                    responseText += `**Key Insights:**\n`;
+                    summaryObj.key_insights.forEach((insight, idx) => {
+                        responseText += `${idx + 1}. ${insight}\n`;
+                    });
+                    responseText += '\n';
+                }
+                if (summaryObj.main_topics && Array.isArray(summaryObj.main_topics)) {
+                    responseText += `**Main Topics:** ${summaryObj.main_topics.join(', ')}\n\n`;
+                }
+                if (summaryObj.actionable_takeaways && Array.isArray(summaryObj.actionable_takeaways)) {
+                    responseText += `**Actionable Takeaways:**\n`;
+                    summaryObj.actionable_takeaways.forEach((takeaway, idx) => {
+                        responseText += `${idx + 1}. ${takeaway}\n`;
+                    });
+                    responseText += '\n';
+                }
+            }
+            // Include full text content info and preview
+            if (content.rawText) {
+                const wordCount = content.rawText.split(/\s+/).length;
+                responseText += `## Full Content\n`;
+                responseText += `**Word Count:** ${wordCount.toLocaleString()} words\n`;
+                // Show a reasonable preview (500 chars is about 100 tokens)
+                responseText += `**Preview (first 500 chars):**\n`;
+                responseText += `${content.rawText.slice(0, 500)}...\n\n`;
+                if (content.tokenCount && content.tokenCount > 10000) {
+                    responseText += `⚠️ **Note:** The complete ${content.contentType} content (${wordCount.toLocaleString()} words, ~${content.tokenCount.toLocaleString()} tokens) is available in the data field.\n`;
+                    responseText += `This is a large amount of content that will consume significant context if fully processed.\n`;
+                }
+                else {
+                    responseText += `*Note: Complete content is available in the data field for analysis.*\n`;
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: content, // Full content including complete rawText
+            };
+        },
+    },
+    {
+        name: "search_content",
+        description: "Advanced search with OR/ANY logic, fuzzy matching, and smart filters. Supports multiple search modes, content type filtering, date ranges, and relevance explanations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query (supports 'term1 OR term2' for any match, quotes for exact phrases)",
+                },
+                searchMode: {
+                    type: "string",
+                    enum: ["any", "all", "phrase"],
+                    description: "Search logic: 'any' (OR logic), 'all' (AND logic), 'phrase' (exact phrase)",
+                    default: "any",
+                },
+                fuzzyMatch: {
+                    type: "boolean",
+                    description: "Enable fuzzy/typo-tolerant matching",
+                    default: true,
+                },
+                tags: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Filter by tags",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum results (default: 10)",
+                    default: 10,
+                },
+                includeFullContent: {
+                    type: "boolean",
+                    description: "Include full text (WARNING: 10k-100k+ tokens)",
+                    default: false,
+                },
+                contentTypes: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: ["youtube", "x_twitter", "reddit", "article", "pdf"],
+                    },
+                    description: "Filter by content types",
+                },
+                dateFrom: {
+                    type: "string",
+                    description: "Content saved after this date (ISO 8601)",
+                },
+                dateTo: {
+                    type: "string",
+                    description: "Content saved before this date (ISO 8601)",
+                },
+                excludeDomains: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Domains to exclude",
+                },
+                showRelevanceExplanation: {
+                    type: "boolean",
+                    description: "Show why each result matched",
+                    default: true,
+                },
+            },
+            required: ["query"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                query: z.string(),
+                searchMode: z.enum(["any", "all", "phrase"]).optional().default("any"),
+                fuzzyMatch: z.boolean().optional().default(true),
+                tags: z.array(z.string()).optional(),
+                limit: z.number().optional().default(10),
+                includeFullContent: z.boolean().optional().default(false),
+                contentTypes: z.array(z.enum(["youtube", "x_twitter", "reddit", "article", "pdf"])).optional(),
+                dateFrom: z.string().optional(),
+                dateTo: z.string().optional(),
+                excludeDomains: z.array(z.string()).optional(),
+                showRelevanceExplanation: z.boolean().optional().default(true),
+            });
+            const params = schema.parse(args);
+            // Enhance search query based on mode
+            let enhancedQuery = params.query;
+            if (params.searchMode === "any" && !params.query.includes("OR")) {
+                // Convert space-separated terms to OR query for broader matching
+                const terms = params.query.split(/\s+/).filter(t => t.length > 2);
+                if (terms.length > 1) {
+                    enhancedQuery = terms.join(" OR ");
+                }
+            }
+            const results = await client.searchContent(enhancedQuery, {
+                ...params,
+                enableConceptExpansion: params.fuzzyMatch, // Use fuzzy matching as concept expansion
+            });
+            // Format response with visual indicators
+            let responseText = `# 🔍 Search Results: "${params.query}"\n`;
+            responseText += `**Mode:** ${params.searchMode.toUpperCase()}${params.fuzzyMatch ? " with fuzzy matching" : ""}\n`;
+            responseText += `**Found:** ${results.length} results`;
+            // Show active filters
+            const filters = [];
+            if (params.tags?.length)
+                filters.push(`📌 tags: ${params.tags.join(", ")}`);
+            if (params.contentTypes?.length)
+                filters.push(`📁 types: ${params.contentTypes.join(", ")}`);
+            if (params.dateFrom || params.dateTo)
+                filters.push(`📅 date range`);
+            if (params.excludeDomains?.length)
+                filters.push(`🚫 excluded: ${params.excludeDomains.join(", ")}`);
+            if (filters.length > 0) {
+                responseText += `\n**Filters:** ${filters.join(" | ")}`;
+            }
+            if (params.includeFullContent) {
+                responseText += `\n⚠️ **Full content included** - consuming significant tokens`;
+            }
+            responseText += `\n\n`;
+            if (results.length > 0) {
+                // Add search suggestions if no perfect matches
+                if (results.length < 3) {
+                    responseText += `💡 **Tip:** Try broader search with 'any' mode or disable filters for more results\n\n`;
+                }
+                results.forEach((result, idx) => {
+                    // Visual indicators for content type
+                    const typeIcons = {
+                        youtube: "📺",
+                        x_twitter: "𝕏",
+                        reddit: "🔗",
+                        article: "📄",
+                        pdf: "📑"
+                    };
+                    const typeIcon = typeIcons[result.contentType] || "📄";
+                    // Relevance indicator
+                    let relevanceIcon = "";
+                    if (result.relevanceScore) {
+                        if (result.relevanceScore > 0.8)
+                            relevanceIcon = "🎯";
+                        else if (result.relevanceScore > 0.6)
+                            relevanceIcon = "✅";
+                        else if (result.relevanceScore > 0.4)
+                            relevanceIcon = "➡️";
+                    }
+                    responseText += `## ${idx + 1}. ${typeIcon} ${result.title || 'Untitled'} ${relevanceIcon}\n`;
+                    responseText += `**ID:** \`${result.id}\`\n`;
+                    responseText += `**URL:** ${result.url}\n`;
+                    // Show relevance explanation if available
+                    if (params.showRelevanceExplanation) {
+                        if (result.matchReason && Array.isArray(result.matchReason)) {
+                            responseText += `**Why matched:** Matched in ${result.matchReason.join(", ")}\n`;
+                        }
+                        else if (result.relevanceScore) {
+                            const percentage = (result.relevanceScore * 100).toFixed(0);
+                            responseText += `**Relevance:** ${percentage}% match\n`;
+                        }
+                    }
+                    // Content size indicator with better formatting
+                    if (result.tokenCount) {
+                        const sizeIcon = result.tokenCount > 50000 ? "🚨" :
+                            result.tokenCount > 10000 ? "⚠️" :
+                                result.tokenCount > 5000 ? "📊" : "📝";
+                        responseText += `**Size:** ${sizeIcon} ~${result.tokenCount.toLocaleString()} tokens`;
+                        if (params.includeFullContent) {
+                            responseText += ` (full content included)`;
+                        }
+                        responseText += `\n`;
+                    }
+                    // Tags with better formatting
+                    if (result.tags && result.tags.length > 0) {
+                        responseText += `**Tags:** ${result.tags.map((t) => `\`${t}\``).join(' ')}\n`;
+                    }
+                    // Summary section with structure
+                    if (result.summary) {
+                        const summaryObj = typeof result.summary === 'string'
+                            ? { text: result.summary }
+                            : result.summary;
+                        if (summaryObj.one_sentence) {
+                            responseText += `\n📝 **Summary:** ${summaryObj.one_sentence}\n`;
+                        }
+                        // Key insights with bullets
+                        if (summaryObj.key_insights && Array.isArray(summaryObj.key_insights) && summaryObj.key_insights.length > 0) {
+                            responseText += `\n💡 **Key Insights:**\n`;
+                            summaryObj.key_insights.slice(0, 3).forEach((insight) => {
+                                responseText += `  • ${insight}\n`;
+                            });
+                        }
+                        // Actionable takeaways
+                        if (summaryObj.actionable_takeaways && Array.isArray(summaryObj.actionable_takeaways) && summaryObj.actionable_takeaways.length > 0) {
+                            responseText += `\n🎯 **Actions:**\n`;
+                            summaryObj.actionable_takeaways.slice(0, 2).forEach((action) => {
+                                responseText += `  → ${action}\n`;
+                            });
+                        }
+                    }
+                    responseText += '\n---\n\n';
+                });
+                // Smart token usage summary
+                if (!params.includeFullContent) {
+                    let totalAvailable = 0;
+                    results.forEach((r) => {
+                        if (r.tokenCount)
+                            totalAvailable += r.tokenCount;
+                    });
+                    if (totalAvailable > 0) {
+                        responseText += `\n📊 **Content Overview:**\n`;
+                        responseText += `- Showing: Summaries and metadata (minimal tokens)\n`;
+                        responseText += `- Available: ~${totalAvailable.toLocaleString()} tokens of full content\n`;
+                        responseText += `- To access: Use \`get_content_details\` for specific items\n`;
+                    }
+                }
+                // Search quality feedback
+                if (results.length === params.limit) {
+                    responseText += `\n💡 **Note:** Showing top ${params.limit} results. More may be available.\n`;
+                }
+            }
+            else {
+                // No results - provide helpful suggestions
+                responseText += "## No Results Found 😔\n\n";
+                responseText += "**Try these approaches:**\n";
+                responseText += "1. 🔄 Switch to `searchMode: 'any'` for broader matching\n";
+                responseText += "2. ✏️ Check spelling or use simpler terms\n";
+                responseText += "3. 🎯 Remove filters (dates, types, domains)\n";
+                responseText += "4. 🔍 Use more general keywords\n";
+                // Suggest alternative queries
+                const terms = params.query.split(/\s+/);
+                if (terms.length > 1) {
+                    responseText += `\n**Alternative queries:**\n`;
+                    responseText += `- "${terms[0]}" (single term)\n`;
+                    responseText += `- "${terms.slice(0, 2).join(' ')}" (first two terms)\n`;
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: results,
+            };
+        },
+    },
+    {
+        name: "save_content",
+        description: "Save a new URL to Noverload for processing",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to save (YouTube, X/Twitter, Reddit, article, or PDF)",
+                },
+            },
+            required: ["url"],
+        },
+        modifies: true,
+        handler: async (client, args) => {
+            const schema = z.object({
+                url: z.string().url(),
+            });
+            const { url } = schema.parse(args);
+            const content = await client.saveContent(url);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: content.title ? `Saved: ${content.title}` : `Saved content from: ${new URL(url).hostname}`,
+                    },
+                ],
+                data: content,
+            };
+        },
+    },
+    {
+        name: "list_actions",
+        description: "List action items extracted from saved content",
+        inputSchema: {
+            type: "object",
+            properties: {
+                contentId: {
+                    type: "string",
+                    description: "Filter by content ID",
+                },
+                goalId: {
+                    type: "string",
+                    description: "Filter by goal ID",
+                },
+                completed: {
+                    type: "boolean",
+                    description: "Filter by completion status",
+                },
+            },
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                contentId: z.string().optional(),
+                goalId: z.string().optional(),
+                completed: z.boolean().optional(),
+            });
+            const params = schema.parse(args);
+            const actions = await client.listActions(params);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Found ${actions.length} actions`,
+                    },
+                ],
+                data: actions,
+            };
+        },
+    },
+    {
+        name: "complete_action",
+        description: "Mark an action item as completed",
+        inputSchema: {
+            type: "object",
+            properties: {
+                actionId: {
+                    type: "string",
+                    description: "The ID of the action to complete",
+                },
+            },
+            required: ["actionId"],
+        },
+        modifies: true,
+        handler: async (client, args) => {
+            const schema = z.object({
+                actionId: z.string(),
+            });
+            const { actionId } = schema.parse(args);
+            const action = await client.completeAction(actionId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Completed action: ${action.title}`,
+                    },
+                ],
+                data: action,
+            };
+        },
+    },
+    {
+        name: "list_goals",
+        description: "List user's goals (Health, Wealth, Relationships)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+        modifies: false,
+        handler: async (client) => {
+            const goals = await client.listGoals();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Found ${goals.length} goals`,
+                    },
+                ],
+                data: goals,
+            };
+        },
+    },
+    {
+        name: "estimate_search_tokens",
+        description: "Estimate token usage before performing a search. Helps manage context window and API costs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query to estimate",
+                },
+                limit: {
+                    type: "number",
+                    description: "Number of results to estimate for",
+                    default: 10,
+                },
+            },
+            required: ["query"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                query: z.string(),
+                limit: z.number().optional().default(10),
+            });
+            const params = schema.parse(args);
+            const estimate = await client.estimateSearchTokens(params.query, params.limit);
+            let responseText = `# Token Estimate for: "${params.query}"\n\n`;
+            responseText += `**Total Estimated Tokens:** ${estimate.totals?.estimatedTokens || 0}\n`;
+            responseText += `**Recommendation:** ${estimate.recommendation || "Unknown"}\n\n`;
+            if (estimate.costEstimate) {
+                responseText += `## Estimated Costs\n`;
+                responseText += `- GPT-4: ${estimate.costEstimate.gpt4}\n`;
+                responseText += `- GPT-3.5: ${estimate.costEstimate.gpt35}\n`;
+                responseText += `- Claude 3: ${estimate.costEstimate.claude3}\n\n`;
+            }
+            if (estimate.estimates && estimate.estimates.length > 0) {
+                responseText += `## Content Breakdown\n`;
+                estimate.estimates.forEach((item, idx) => {
+                    responseText += `${idx + 1}. ${item.title || "Untitled"} - ${item.estimatedTokens} tokens\n`;
+                });
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: estimate,
+            };
+        },
+    },
+    {
+        name: "synthesize_content",
+        description: "Analyze multiple content sources to generate actionable insights, find patterns, connections, and contradictions. Creates structured synthesis with timeline, next steps, and confidence scores.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Topic or question to synthesize insights about",
+                },
+                contentIds: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Specific content IDs to analyze (optional, otherwise uses search)",
+                },
+                synthesisMode: {
+                    type: "string",
+                    enum: ["overview", "deep", "actionable", "comparison"],
+                    description: "Type of synthesis to perform (default: actionable)",
+                    default: "actionable",
+                },
+                findContradictions: {
+                    type: "boolean",
+                    description: "Look for contradictions between sources",
+                    default: false,
+                },
+                findConnections: {
+                    type: "boolean",
+                    description: "Find connections and patterns across sources",
+                    default: true,
+                },
+                maxSources: {
+                    type: "number",
+                    description: "Maximum number of sources to analyze",
+                    default: 10,
+                },
+            },
+            required: ["query"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                query: z.string(),
+                contentIds: z.array(z.string()).optional(),
+                synthesisMode: z.enum(["overview", "deep", "actionable", "comparison"]).optional().default("actionable"),
+                findContradictions: z.boolean().optional().default(false),
+                findConnections: z.boolean().optional().default(true),
+                maxSources: z.number().optional().default(10),
+            });
+            const params = schema.parse(args);
+            const result = await client.synthesizeContent(params);
+            // Handle the API v2 response format
+            const synthesis = result.synthesis || result;
+            const metadata = result.metadata || {};
+            const sources = result.sources || [];
+            let responseText = `# 🎯 Synthesis: "${params.query}"\n`;
+            responseText += `**Mode:** ${synthesis.mode || params.synthesisMode} | **Sources:** ${metadata.sourceCount || sources.length}`;
+            // Add confidence indicator if available
+            if (metadata.confidence) {
+                const confidenceIcon = metadata.confidence >= 80 ? "🟢" : metadata.confidence >= 60 ? "🟡" : "🔴";
+                responseText += ` | **Confidence:** ${confidenceIcon} ${metadata.confidence}%`;
+            }
+            responseText += `\n\n`;
+            // Summary Section
+            if (synthesis.summary) {
+                responseText += `## 📋 Summary\n${synthesis.summary}\n\n`;
+            }
+            // Insights Section (most important)
+            if (synthesis.insights && synthesis.insights.length > 0) {
+                responseText += `## 💡 Key Insights\n`;
+                synthesis.insights.forEach((insight, idx) => {
+                    // Handle both string and object insights
+                    if (typeof insight === 'string') {
+                        responseText += `${idx + 1}. ${insight}\n`;
+                    }
+                    else if (insight.text) {
+                        responseText += `${idx + 1}. **${insight.text}**`;
+                        if (insight.sourceTitle) {
+                            responseText += ` *(from: ${insight.sourceTitle})*`;
+                        }
+                        responseText += `\n`;
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Themes Section
+            if (synthesis.themes && synthesis.themes.length > 0) {
+                responseText += `## 🎨 Major Themes\n`;
+                synthesis.themes.forEach((theme) => {
+                    if (typeof theme === 'string') {
+                        responseText += `- ${theme}\n`;
+                    }
+                    else if (theme.theme) {
+                        responseText += `\n### ${theme.theme}`;
+                        if (theme.prevalence) {
+                            responseText += ` (strength: ${theme.prevalence})`;
+                        }
+                        responseText += `\n`;
+                        if (theme.concepts && theme.concepts.length > 0) {
+                            responseText += `Related concepts: `;
+                            responseText += theme.concepts.slice(0, 3).map((c) => typeof c === 'string' ? c : c.concept).join(', ');
+                            responseText += `\n`;
+                        }
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Priorities (for actionable mode)
+            if (synthesis.priorities) {
+                responseText += `## 🎯 Priorities\n`;
+                if (synthesis.priorities.high && synthesis.priorities.high.length > 0) {
+                    responseText += `\n### 🔴 High Priority\n`;
+                    synthesis.priorities.high.forEach((item) => {
+                        responseText += `- ${item}\n`;
+                    });
+                }
+                if (synthesis.priorities.medium && synthesis.priorities.medium.length > 0) {
+                    responseText += `\n### 🟡 Medium Priority\n`;
+                    synthesis.priorities.medium.forEach((item) => {
+                        responseText += `- ${item}\n`;
+                    });
+                }
+                if (synthesis.priorities.low && synthesis.priorities.low.length > 0) {
+                    responseText += `\n### 🟢 Low Priority\n`;
+                    synthesis.priorities.low.forEach((item) => {
+                        responseText += `- ${item}\n`;
+                    });
+                }
+                responseText += `\n`;
+            }
+            // Implementation Steps (for actionable mode)
+            if (synthesis.implementation && synthesis.implementation.length > 0) {
+                responseText += `## 📝 Implementation Steps\n`;
+                synthesis.implementation.forEach((step, idx) => {
+                    responseText += `${idx + 1}. ${step}\n`;
+                });
+                responseText += `\n`;
+            }
+            // Source Comparison (for comparative mode)
+            if (synthesis.sourceComparison && synthesis.sourceComparison.length > 0) {
+                responseText += `## 📊 Source Comparison\n`;
+                synthesis.sourceComparison.forEach((source) => {
+                    responseText += `\n### ${source.source}\n`;
+                    responseText += `- **Insights:** ${source.insightCount}\n`;
+                    if (source.mainThemes && source.mainThemes.length > 0) {
+                        responseText += `- **Main themes:** ${source.mainThemes.join(', ')}\n`;
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Commonalities and Differences
+            if (synthesis.commonalities && synthesis.commonalities.length > 0) {
+                responseText += `## ✅ Common Themes Across Sources\n`;
+                synthesis.commonalities.forEach((theme) => {
+                    responseText += `- ${theme}\n`;
+                });
+                responseText += `\n`;
+            }
+            if (synthesis.differences && synthesis.differences.length > 0) {
+                responseText += `## 🔀 Unique Perspectives\n`;
+                synthesis.differences.forEach((diff) => {
+                    responseText += `- **${diff.source}:** ${diff.themes.join(', ')}\n`;
+                });
+                responseText += `\n`;
+            }
+            // Connections
+            if (synthesis.connections && synthesis.connections.length > 0) {
+                responseText += `## 🔗 Connections & Patterns\n`;
+                synthesis.connections.forEach((conn) => {
+                    if (conn.concept && conn.sources) {
+                        responseText += `- **${conn.concept}** appears in: ${conn.sources.join(', ')}`;
+                        if (conn.strength) {
+                            responseText += ` (strength: ${conn.strength})`;
+                        }
+                        responseText += `\n`;
+                    }
+                    else if (conn.pattern) {
+                        responseText += `- **${conn.pattern}**`;
+                        if (conn.implication) {
+                            responseText += `: ${conn.implication}`;
+                        }
+                        responseText += `\n`;
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Contradictions
+            if (synthesis.contradictions && synthesis.contradictions.length > 0) {
+                responseText += `## ⚡ Contradictions Found\n`;
+                synthesis.contradictions.forEach((contra) => {
+                    if (contra.source1 && contra.statement1) {
+                        responseText += `\n### Potential Contradiction\n`;
+                        responseText += `- **${contra.source1}:** "${contra.statement1}"\n`;
+                        responseText += `- **${contra.source2}:** "${contra.statement2}"\n`;
+                        if (contra.type) {
+                            responseText += `- **Type:** ${contra.type}\n`;
+                        }
+                    }
+                    else if (contra.topic) {
+                        responseText += `\n### ${contra.topic}\n`;
+                        if (contra.viewpoints) {
+                            contra.viewpoints.forEach((vp) => {
+                                responseText += `- **${vp.position}:** ${vp.argument}\n`;
+                            });
+                        }
+                        if (contra.resolution) {
+                            responseText += `**Suggested resolution:** ${contra.resolution}\n`;
+                        }
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Timeline
+            if (synthesis.timeline && synthesis.timeline.length > 0) {
+                responseText += `## ⏱️ Timeline\n`;
+                synthesis.timeline.forEach((event) => {
+                    if (event.date) {
+                        responseText += `- **${event.date}:** ${event.event}`;
+                        if (event.source) {
+                            responseText += ` *(${event.source})*`;
+                        }
+                        responseText += `\n`;
+                    }
+                    else if (event.phase) {
+                        responseText += `\n### ${event.phase}`;
+                        if (event.duration) {
+                            responseText += ` (${event.duration})`;
+                        }
+                        responseText += `\n`;
+                        if (event.activities && event.activities.length > 0) {
+                            event.activities.forEach((activity) => {
+                                responseText += `- ${activity}\n`;
+                            });
+                        }
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Action Plan
+            if (synthesis.actionPlan) {
+                responseText += `## 🚀 Action Plan\n`;
+                if (synthesis.actionPlan.summary) {
+                    responseText += `${synthesis.actionPlan.summary}\n\n`;
+                }
+                if (synthesis.actionPlan.nextAction) {
+                    responseText += `**🎯 Next Action:** ${synthesis.actionPlan.nextAction.action || synthesis.actionPlan.nextAction}\n\n`;
+                }
+                if (synthesis.actionPlan.steps && synthesis.actionPlan.steps.length > 0) {
+                    responseText += `### Steps\n`;
+                    synthesis.actionPlan.steps.forEach((step, idx) => {
+                        const priorityIcon = step.priority === "high" ? "🔴" : step.priority === "medium" ? "🟡" : "🟢";
+                        responseText += `${idx + 1}. ${priorityIcon} **${step.action}**`;
+                        if (step.timeframe) {
+                            responseText += ` *(${step.timeframe})*`;
+                        }
+                        if (step.reasoning) {
+                            responseText += `\n   - Reasoning: ${step.reasoning}`;
+                        }
+                        responseText += `\n`;
+                    });
+                }
+                responseText += `\n`;
+            }
+            // Key Facts (if available)
+            if (synthesis.keyFacts && synthesis.keyFacts.length > 0) {
+                responseText += `## 📌 Key Facts\n`;
+                synthesis.keyFacts.slice(0, 5).forEach((fact) => {
+                    if (typeof fact === 'string') {
+                        responseText += `- ${fact}\n`;
+                    }
+                    else if (fact.text) {
+                        responseText += `- ${fact.text}`;
+                        if (fact.sourceTitle) {
+                            responseText += ` *(${fact.sourceTitle})*`;
+                        }
+                        responseText += `\n`;
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Source Information
+            if (sources && sources.length > 0) {
+                responseText += `## 📚 Sources Analyzed\n`;
+                sources.forEach((source, idx) => {
+                    const typeIcons = {
+                        youtube: "📺",
+                        x_twitter: "𝕏",
+                        reddit: "🔗",
+                        article: "📄",
+                        pdf: "📑"
+                    };
+                    const typeIcon = typeIcons[source.type] || "📄";
+                    responseText += `${idx + 1}. ${typeIcon} [${source.title}](${source.url})\n`;
+                });
+                responseText += `\n`;
+            }
+            // Metadata Footer
+            responseText += `---\n`;
+            responseText += `*Analysis completed in ${metadata.executionTime ? `${metadata.executionTime}ms` : 'N/A'}`;
+            if (metadata.totalTokens) {
+                responseText += ` | Processed ${metadata.totalTokens.toLocaleString()} tokens`;
+            }
+            if (metadata.focusAreas && metadata.focusAreas.length > 0) {
+                responseText += ` | Focus: ${metadata.focusAreas.join(', ')}`;
+            }
+            responseText += `*\n`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: result,
+            };
+        },
+    },
+    {
+        name: "find_similar_content",
+        description: "Find content similar to a specific saved item using semantic similarity.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                contentId: {
+                    type: "string",
+                    description: "ID of the content to find similar items for",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of similar items to return",
+                    default: 5,
+                },
+                minSimilarity: {
+                    type: "number",
+                    description: "Minimum similarity score (0-1)",
+                    default: 0.7,
+                },
+            },
+            required: ["contentId"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                contentId: z.string(),
+                limit: z.number().optional().default(5),
+                minSimilarity: z.number().optional().default(0.7),
+            });
+            const params = schema.parse(args);
+            const result = await client.findSimilarContent(params.contentId, {
+                limit: params.limit,
+                minSimilarity: params.minSimilarity,
+            });
+            let responseText = `# Similar Content to: ${result.source?.title || "Unknown"}\n\n`;
+            if (result.similarContent && result.similarContent.length > 0) {
+                responseText += `Found ${result.similarContent.length} similar items:\n\n`;
+                result.similarContent.forEach((item, idx) => {
+                    responseText += `## ${idx + 1}. ${item.title || "Untitled"}\n`;
+                    responseText += `**Similarity:** ${(item.similarity * 100).toFixed(1)}%\n`;
+                    responseText += `**Type:** ${item.type || item.contentType || "unknown"} | **URL:** ${item.url}\n`;
+                    if (item.summary) {
+                        responseText += `**Summary:** ${item.summary}\n`;
+                    }
+                    responseText += `\n`;
+                });
+            }
+            else {
+                responseText += `No similar content found with similarity >= ${params.minSimilarity}`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: result,
+            };
+        },
+    },
+    {
+        name: "batch_get_content",
+        description: "Fetch multiple content items in a single request. Efficient for bulk operations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ids: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Array of content IDs to fetch",
+                },
+                includeFullContent: {
+                    type: "boolean",
+                    description: "Include full text content (warning: may use many tokens)",
+                    default: false,
+                },
+            },
+            required: ["ids"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                ids: z.array(z.string()).min(1).max(50),
+                includeFullContent: z.boolean().optional().default(false),
+            });
+            const params = schema.parse(args);
+            const result = await client.batchGetContent(params.ids, params.includeFullContent);
+            let responseText = `# Batch Content Fetch\n\n`;
+            responseText += `Requested: ${params.ids.length} items\n`;
+            responseText += `Found: ${result.metadata?.found || 0} items\n`;
+            // Calculate and warn about total tokens
+            let totalTokens = 0;
+            if (result.results && result.results.length > 0) {
+                result.results.forEach((item) => {
+                    if (item.tokenCount)
+                        totalTokens += item.tokenCount;
+                });
+            }
+            if (params.includeFullContent && totalTokens > 0) {
+                responseText += `\n⚠️ **Full Content Included - Total Size: ${totalTokens.toLocaleString()} tokens**`;
+                if (totalTokens > 100000) {
+                    responseText += ` 🚨 EXTREMELY LARGE!\n`;
+                    responseText += `WARNING: This WILL consume most or all of your context window!\n`;
+                    responseText += `Consider setting includeFullContent: false to just get summaries.\n`;
+                }
+                else if (totalTokens > 50000) {
+                    responseText += ` 🚨 VERY LARGE!\n`;
+                    responseText += `This is consuming significant context. Use with caution.\n`;
+                }
+                else if (totalTokens > 10000) {
+                    responseText += ` ⚠️\n`;
+                }
+                else {
+                    responseText += `\n`;
+                }
+            }
+            else if (!params.includeFullContent && totalTokens > 0) {
+                responseText += `\n💡 **Showing summaries only.** Total content available: ~${totalTokens.toLocaleString()} tokens.\n`;
+                responseText += `Rich metadata (summaries, tags, insights) included with minimal token usage.\n`;
+            }
+            responseText += `\n`;
+            if (result.results && result.results.length > 0) {
+                result.results.forEach((item, idx) => {
+                    if (item.error) {
+                        responseText += `## ${idx + 1}. Error: ${item.id}\n`;
+                        responseText += `${item.error}\n\n`;
+                    }
+                    else {
+                        responseText += `## ${idx + 1}. ${item.title || "Untitled"}\n`;
+                        responseText += `**ID:** ${item.id}\n`;
+                        responseText += `**Type:** ${item.contentType} | **URL:** ${item.url}\n`;
+                        if (item.tokenCount) {
+                            responseText += `**Tokens:** ${item.tokenCount.toLocaleString()}`;
+                            if (item.tokenCount > 10000)
+                                responseText += ` ⚠️`;
+                            responseText += `\n`;
+                        }
+                        if (item.summary) {
+                            responseText += `**Summary:** ${typeof item.summary === "string" ? item.summary : item.summary.one_sentence || "N/A"}\n`;
+                        }
+                        if (params.includeFullContent && item.fullContent) {
+                            responseText += `**Content Length:** ${item.metadata?.contentLength || 0} characters\n`;
+                        }
+                        responseText += `\n`;
+                    }
+                });
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: result,
+            };
+        },
+    },
+    {
+        name: "get_instructions",
+        description: "Get instructions for optimal MCP usage, including capabilities, best practices, and example workflows",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    description: "Specific topic for instructions (optional)",
+                    enum: ["search", "synthesis", "retrieval", "general"],
+                },
+                includeExamples: {
+                    type: "boolean",
+                    description: "Include workflow examples",
+                    default: true,
+                },
+            },
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                topic: z.enum(["search", "synthesis", "retrieval", "general"]).optional(),
+                includeExamples: z.boolean().optional().default(true),
+            });
+            const params = schema.parse(args);
+            const instructions = generateLLMInstructions();
+            let responseText = `# Noverload MCP Usage Instructions\n\n`;
+            responseText += `## Version: ${instructions.version}\n\n`;
+            if (!params.topic || params.topic === "general") {
+                // Show all capabilities
+                responseText += `## Capabilities Overview\n\n`;
+                for (const [key, capability] of Object.entries(instructions.capabilities)) {
+                    responseText += `### ${key.charAt(0).toUpperCase() + key.slice(1)}\n`;
+                    responseText += `${capability.description}\n\n`;
+                    responseText += `**Strengths:**\n`;
+                    capability.strengths.forEach((s) => responseText += `- ${s}\n`);
+                    responseText += `\n**When to use:**\n`;
+                    capability.whenToUse.forEach((w) => responseText += `- ${w}\n`);
+                    responseText += `\n`;
+                }
+                responseText += `## Best Practices\n\n`;
+                for (const [scenario, practice] of Object.entries(instructions.bestPractices)) {
+                    responseText += `**${scenario.replace(/([A-Z])/g, ' $1').toLowerCase()}:** ${practice}\n`;
+                }
+                responseText += `\n`;
+            }
+            else {
+                // Show specific capability
+                const capability = instructions.capabilities[params.topic];
+                if (capability) {
+                    responseText += `## ${params.topic.charAt(0).toUpperCase() + params.topic.slice(1)} Capability\n\n`;
+                    responseText += `${capability.description}\n\n`;
+                    responseText += `### Strengths\n`;
+                    capability.strengths.forEach(s => responseText += `- ${s}\n`);
+                    responseText += `\n### Limitations\n`;
+                    capability.limitations.forEach(l => responseText += `- ${l}\n`);
+                    responseText += `\n### When to Use\n`;
+                    capability.whenToUse.forEach(w => responseText += `- ${w}\n`);
+                }
+            }
+            if (params.includeExamples && instructions.exampleWorkflows.length > 0) {
+                responseText += `\n## Example Workflows\n\n`;
+                instructions.exampleWorkflows.forEach((example, idx) => {
+                    responseText += `### ${idx + 1}. ${example.scenario}\n`;
+                    responseText += `**Steps:**\n`;
+                    example.steps.forEach((step, i) => responseText += `${i + 1}. ${step}\n`);
+                    responseText += `**Expected Outcome:** ${example.expectedOutcome}\n\n`;
+                });
+            }
+            responseText += `## Token Management\n\n`;
+            responseText += `- Search results limit: ${instructions.tokenManagement.searchResultsLimit}\n`;
+            responseText += `- Use chunking: ${instructions.tokenManagement.useChunking ? 'Yes' : 'No'}\n`;
+            responseText += `- Get summaries first: ${instructions.tokenManagement.summaryFirst ? 'Yes' : 'No'}\n`;
+            responseText += `- Max content per query: ${instructions.tokenManagement.maxContentPerQuery.toLocaleString()} tokens\n`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: instructions,
+            };
+        },
+    },
+    {
+        name: "plan_query",
+        description: "Plan an optimal query strategy for complex requests, with token estimates",
+        inputSchema: {
+            type: "object",
+            properties: {
+                request: {
+                    type: "string",
+                    description: "The user's request to plan for",
+                },
+            },
+            required: ["request"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                request: z.string(),
+            });
+            const { request } = schema.parse(args);
+            const availableTools = [
+                "search_content",
+                "get_content_details",
+                "synthesize_content",
+                "find_similar_content",
+                "list_saved_content"
+            ];
+            const plan = planQueryStrategy(request, availableTools);
+            let responseText = `# Query Plan for: "${request}"\n\n`;
+            responseText += `## Strategy: ${plan.strategy}\n`;
+            responseText += `## Estimated Tokens: ~${plan.estimatedTokens.toLocaleString()}\n\n`;
+            responseText += `## Execution Steps:\n\n`;
+            plan.steps.forEach((step, idx) => {
+                responseText += `### Step ${idx + 1}: ${step.tool}\n`;
+                responseText += `**Purpose:** ${step.purpose}\n`;
+                responseText += `**Parameters:**\n`;
+                for (const [key, value] of Object.entries(step.params)) {
+                    responseText += `- ${key}: ${JSON.stringify(value)}\n`;
+                }
+                const tokenEstimate = estimateTokenUsage({ tool: step.tool, params: step.params });
+                responseText += `**Estimated Tokens:** ~${tokenEstimate.estimated.toLocaleString()}`;
+                if (tokenEstimate.warning) {
+                    responseText += ` ⚠️ ${tokenEstimate.warning}`;
+                }
+                responseText += `\n`;
+                if (tokenEstimate.suggestion) {
+                    responseText += `**Suggestion:** ${tokenEstimate.suggestion}\n`;
+                }
+                responseText += `\n`;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: plan,
+            };
+        },
+    },
+    {
+        name: "get_raw_content",
+        description: "Access full raw text of saved content with smart chunking for large documents. Requires confirmation for content >10k tokens. Returns complete unprocessed text or intelligently chunked sections.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                contentId: {
+                    type: "string",
+                    description: "The ID of the content to retrieve raw text for",
+                },
+                format: {
+                    type: "string",
+                    enum: ["full", "chunks", "sections"],
+                    description: "Format: 'full' (complete text), 'chunks' (semantic chunks), 'sections' (logical sections)",
+                    default: "chunks",
+                },
+                maxTokens: {
+                    type: "number",
+                    description: "Maximum tokens to return (only for chunks/sections format)",
+                    default: 50000,
+                },
+                chunkSize: {
+                    type: "number",
+                    description: "Target size for each chunk in tokens (for chunks format)",
+                    default: 4000,
+                },
+                includeMetadata: {
+                    type: "boolean",
+                    description: "Include metadata about sections/chunks",
+                    default: true,
+                },
+                confirmLargeContent: {
+                    type: "boolean",
+                    description: "Confirm retrieval of large content (>10k tokens)",
+                    default: false,
+                },
+            },
+            required: ["contentId"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                contentId: z.string(),
+                format: z.enum(["full", "chunks", "sections"]).optional().default("chunks"),
+                maxTokens: z.number().optional().default(50000),
+                chunkSize: z.number().optional().default(4000),
+                includeMetadata: z.boolean().optional().default(true),
+                confirmLargeContent: z.boolean().optional().default(false),
+            });
+            const params = schema.parse(args);
+            // First get content metadata to check size
+            const content = await client.getContent(params.contentId);
+            if (!content.rawText) {
+                // Try to get raw content through v2 API with enrichment
+                const enrichedResult = await client.getEnrichedContent([params.contentId], true);
+                if (!enrichedResult || enrichedResult.length === 0 || !enrichedResult[0].rawText) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `No raw text available for content ID: ${params.contentId}. Content may still be processing or does not contain extractable text.`,
+                            },
+                        ],
+                        data: null,
+                    };
+                }
+                // Use the enriched content
+                content.rawText = enrichedResult[0].rawText;
+                content.tokenCount = enrichedResult[0].tokenCount;
+            }
+            const wordCount = content.rawText ? content.rawText.split(/\s+/).length : 0;
+            const estimatedTokens = content.tokenCount || Math.ceil(wordCount * 1.3);
+            // Check if confirmation is needed for large content
+            if (params.format === "full" && estimatedTokens > 10000 && !params.confirmLargeContent) {
+                let warningText = `# ⚠️ Large Content Warning\n\n`;
+                warningText += `**Content:** ${content.title || 'Untitled'}\n`;
+                warningText += `**Size:** ${wordCount.toLocaleString()} words (~${estimatedTokens.toLocaleString()} tokens)\n\n`;
+                if (estimatedTokens > 100000) {
+                    warningText += `## 🚨 CRITICAL: Extremely Large Content\n`;
+                    warningText += `This content contains ${estimatedTokens.toLocaleString()} tokens and will **exceed most LLM context windows**.\n\n`;
+                    warningText += `**Recommendations:**\n`;
+                    warningText += `1. Use format='chunks' to process in smaller pieces\n`;
+                    warningText += `2. Use format='sections' to get logical divisions\n`;
+                    warningText += `3. Use search_content to find specific information\n`;
+                    warningText += `4. Use synthesize_content to get key insights without full text\n\n`;
+                }
+                else if (estimatedTokens > 50000) {
+                    warningText += `## ⚠️ Very Large Content\n`;
+                    warningText += `This content contains ${estimatedTokens.toLocaleString()} tokens and will use **most of your context window**.\n\n`;
+                    warningText += `**Consider:**\n`;
+                    warningText += `- Using format='chunks' for manageable pieces\n`;
+                    warningText += `- Using search or synthesis tools instead\n\n`;
+                }
+                else {
+                    warningText += `## Large Content Notice\n`;
+                    warningText += `This content will use ${estimatedTokens.toLocaleString()} tokens of your context.\n\n`;
+                }
+                warningText += `**To proceed with full text retrieval:**\n`;
+                warningText += `Call get_raw_content again with:\n`;
+                warningText += `- contentId: "${params.contentId}"\n`;
+                warningText += `- format: "full"\n`;
+                warningText += `- confirmLargeContent: true\n\n`;
+                warningText += `**Alternative approaches:**\n`;
+                warningText += `- format: "chunks" - Get content in ${Math.ceil(estimatedTokens / params.chunkSize)} chunks of ~${params.chunkSize} tokens\n`;
+                warningText += `- format: "sections" - Get logical sections with headers\n`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: warningText,
+                        },
+                    ],
+                    data: {
+                        requiresConfirmation: true,
+                        contentId: params.contentId,
+                        title: content.title,
+                        estimatedTokens,
+                        suggestedFormat: estimatedTokens > 50000 ? "chunks" : "sections",
+                        chunkCount: Math.ceil(estimatedTokens / params.chunkSize),
+                    },
+                };
+            }
+            let responseText = `# Raw Content: ${content.title || 'Untitled'}\n\n`;
+            responseText += `**Content Type:** ${content.contentType}\n`;
+            responseText += `**URL:** ${content.url}\n`;
+            responseText += `**Size:** ${wordCount.toLocaleString()} words (~${estimatedTokens.toLocaleString()} tokens)\n`;
+            // Add appropriate warning based on size
+            if (estimatedTokens > 50000 && params.format === "full") {
+                responseText += `\n⚠️ **Large content confirmed** - Returning ${estimatedTokens.toLocaleString()} tokens\n\n`;
+            }
+            let resultData = {
+                id: content.id,
+                title: content.title,
+                contentType: content.contentType,
+                totalTokens: estimatedTokens,
+                format: params.format,
+            };
+            if (params.format === "full") {
+                // Return full text (with confirmation)
+                responseText += `\n## Full Text Content\n`;
+                responseText += `*Complete raw text (${estimatedTokens.toLocaleString()} tokens) is available in the data field.*\n`;
+                resultData.text = content.rawText;
+                resultData.metadata = params.includeMetadata ? {
+                    wordCount,
+                    estimatedTokens,
+                    contentType: content.contentType,
+                    extractedAt: content.createdAt,
+                } : undefined;
+            }
+            else if (params.format === "chunks") {
+                // Smart chunking based on token size
+                const chunks = chunkContent(content.rawText || "", params.chunkSize, params.maxTokens);
+                responseText += `\n## Content Chunks\n`;
+                responseText += `**Total Chunks:** ${chunks.length}\n`;
+                responseText += `**Chunk Size:** ~${params.chunkSize} tokens each\n`;
+                if (chunks.length * params.chunkSize > params.maxTokens) {
+                    responseText += `**Note:** Showing first ${chunks.length} chunks (limited by maxTokens: ${params.maxTokens})\n`;
+                }
+                responseText += `\n`;
+                // Show chunk previews
+                chunks.slice(0, 3).forEach((chunk, idx) => {
+                    responseText += `### Chunk ${idx + 1}/${chunks.length}\n`;
+                    responseText += `**Tokens:** ~${chunk.tokenCount}\n`;
+                    responseText += `**Preview:** ${chunk.text.slice(0, 200)}...\n\n`;
+                });
+                if (chunks.length > 3) {
+                    responseText += `*... and ${chunks.length - 3} more chunks*\n\n`;
+                }
+                responseText += `💡 **Tip:** To get a specific chunk, note the chunk index and request it directly.\n`;
+                resultData.chunks = chunks;
+                resultData.totalChunks = chunks.length;
+            }
+            else if (params.format === "sections") {
+                // Logical section detection (headers, paragraphs, etc.)
+                const sections = detectSections(content.rawText || "", content.contentType);
+                responseText += `\n## Content Sections\n`;
+                responseText += `**Total Sections:** ${sections.length}\n\n`;
+                // Show section outline
+                let totalSectionTokens = 0;
+                sections.forEach((section, idx) => {
+                    responseText += `${idx + 1}. **${section.title || `Section ${idx + 1}`}**`;
+                    if (section.type) {
+                        responseText += ` (${section.type})`;
+                    }
+                    responseText += ` - ~${section.tokenCount} tokens\n`;
+                    totalSectionTokens += section.tokenCount;
+                    if (totalSectionTokens > params.maxTokens) {
+                        responseText += `   *[Exceeds maxTokens limit]*\n`;
+                    }
+                });
+                responseText += `\n*Full section content available in data field*\n`;
+                resultData.sections = sections;
+                resultData.totalSections = sections.length;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: resultData,
+            };
+        },
+    },
+    {
+        name: "explore_topic",
+        description: "Deep exploration of a topic across all saved content. Provides comprehensive understanding with multiple perspectives, evolution over time, and key concepts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    description: "The topic to explore comprehensively",
+                },
+                depth: {
+                    type: "string",
+                    enum: ["surface", "comprehensive", "expert"],
+                    description: "Depth of exploration",
+                    default: "comprehensive",
+                },
+                includeTimeline: {
+                    type: "boolean",
+                    description: "Include chronological evolution of the topic",
+                    default: true,
+                },
+                includeConnections: {
+                    type: "boolean",
+                    description: "Find connections to related topics",
+                    default: true,
+                },
+                maxSources: {
+                    type: "number",
+                    description: "Maximum number of sources to analyze",
+                    default: 20,
+                },
+            },
+            required: ["topic"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                topic: z.string(),
+                depth: z.enum(["surface", "comprehensive", "expert"]).optional().default("comprehensive"),
+                includeTimeline: z.boolean().optional().default(true),
+                includeConnections: z.boolean().optional().default(true),
+                maxSources: z.number().optional().default(20),
+            });
+            const params = schema.parse(args);
+            // Search for all content related to the topic
+            const searchResults = await client.searchContent(params.topic, {
+                limit: params.maxSources,
+                enableConceptExpansion: true,
+                fuzzyMatch: true,
+            });
+            if (!searchResults || searchResults.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No content found for topic: "${params.topic}". Try saving relevant content first or use a different search term.`,
+                        },
+                    ],
+                    data: null,
+                };
+            }
+            // Synthesize the content for deep understanding
+            const synthesis = await client.synthesizeContent({
+                query: `Comprehensive exploration of ${params.topic}`,
+                contentIds: searchResults.slice(0, params.maxSources).map((r) => r.id),
+                synthesisMode: params.depth === "expert" ? "deep" : params.depth === "surface" ? "overview" : "actionable",
+                findConnections: params.includeConnections,
+                findContradictions: true,
+            });
+            let responseText = `# 🔍 Topic Exploration: "${params.topic}"\n`;
+            responseText += `**Depth:** ${params.depth} | **Sources Analyzed:** ${searchResults.length}\n\n`;
+            // Overview Section
+            responseText += `## 📋 Overview\n`;
+            if (synthesis.synthesis?.summary) {
+                responseText += `${synthesis.synthesis.summary}\n\n`;
+            }
+            else {
+                responseText += `Analysis of ${searchResults.length} pieces of content about ${params.topic}.\n\n`;
+            }
+            // Key Concepts
+            responseText += `## 🎯 Key Concepts\n`;
+            const concepts = extractKeyConceptsFromSearch(searchResults, params.topic);
+            concepts.slice(0, 10).forEach((concept, idx) => {
+                responseText += `${idx + 1}. ${concept}\n`;
+            });
+            responseText += `\n`;
+            // Multiple Perspectives
+            responseText += `## 👥 Different Perspectives\n`;
+            const perspectives = groupByPerspective(searchResults);
+            Object.entries(perspectives).slice(0, 5).forEach(([perspective, items]) => {
+                responseText += `\n### ${perspective}\n`;
+                responseText += `*Found in ${items.length} sources*\n`;
+                if (items[0]?.summary) {
+                    const summary = typeof items[0].summary === 'string' ? items[0].summary : items[0].summary.one_sentence;
+                    responseText += `Example: "${summary?.slice(0, 200)}..."\n`;
+                }
+            });
+            responseText += `\n`;
+            // Timeline (if requested)
+            if (params.includeTimeline && searchResults.length > 1) {
+                responseText += `## ⏱️ Topic Evolution\n`;
+                const timeline = createTopicTimeline(searchResults);
+                timeline.forEach((event) => {
+                    responseText += `- **${event.date}:** ${event.title} - ${event.insight}\n`;
+                });
+                responseText += `\n`;
+            }
+            // Connections (if found)
+            if (params.includeConnections && synthesis.synthesis?.connections) {
+                responseText += `## 🔗 Related Topics & Connections\n`;
+                synthesis.synthesis.connections.slice(0, 8).forEach((conn) => {
+                    if (typeof conn === 'string') {
+                        responseText += `- ${conn}\n`;
+                    }
+                    else if (conn.concept) {
+                        responseText += `- **${conn.concept}**`;
+                        if (conn.strength) {
+                            responseText += ` (strength: ${conn.strength})`;
+                        }
+                        responseText += `\n`;
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Contradictions & Debates
+            if (synthesis.synthesis?.contradictions && synthesis.synthesis.contradictions.length > 0) {
+                responseText += `## ⚡ Contradictions & Debates\n`;
+                synthesis.synthesis.contradictions.slice(0, 3).forEach((contra) => {
+                    responseText += `\n**Point of Contention:**\n`;
+                    if (contra.topic) {
+                        responseText += `${contra.topic}\n`;
+                    }
+                    if (contra.viewpoints) {
+                        contra.viewpoints.forEach((vp) => {
+                            responseText += `- ${vp.position}: ${vp.argument}\n`;
+                        });
+                    }
+                });
+                responseText += `\n`;
+            }
+            // Learning Path (for comprehensive/expert depth)
+            if (params.depth !== "surface") {
+                responseText += `## 📚 Suggested Learning Path\n`;
+                const learningPath = createLearningPath(searchResults, params.topic);
+                learningPath.forEach((step, idx) => {
+                    responseText += `${idx + 1}. **${step.title}** - ${step.reason}\n`;
+                });
+                responseText += `\n`;
+            }
+            // Expert Insights (for expert depth)
+            if (params.depth === "expert" && synthesis.synthesis?.insights) {
+                responseText += `## 💡 Expert-Level Insights\n`;
+                synthesis.synthesis.insights.slice(0, 5).forEach((insight, idx) => {
+                    const text = typeof insight === 'string' ? insight : insight.text;
+                    responseText += `${idx + 1}. ${text}\n`;
+                });
+                responseText += `\n`;
+            }
+            // Sources
+            responseText += `## 📚 Top Sources\n`;
+            searchResults.slice(0, 5).forEach((source, idx) => {
+                const typeIcons = {
+                    youtube: "📺",
+                    x_twitter: "𝕏",
+                    reddit: "🔗",
+                    article: "📄",
+                    pdf: "📑"
+                };
+                const icon = typeIcons[source.contentType] || "📄";
+                responseText += `${idx + 1}. ${icon} [${source.title || "Untitled"}](${source.url})\n`;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: {
+                    topic: params.topic,
+                    depth: params.depth,
+                    sourcesAnalyzed: searchResults.length,
+                    synthesis: synthesis.synthesis,
+                    sources: searchResults,
+                    concepts,
+                    perspectives,
+                },
+            };
+        },
+    },
+    {
+        name: "find_connections",
+        description: "Discover connections and relationships between different pieces of content. Identifies causal links, contradictions, and complementary information.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                contentIds: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Array of content IDs to find connections between",
+                },
+                connectionType: {
+                    type: "string",
+                    enum: ["all", "causal", "contradictory", "complementary", "sequential"],
+                    description: "Type of connections to find",
+                    default: "all",
+                },
+                depth: {
+                    type: "number",
+                    description: "How many levels deep to search for connections (1-3)",
+                    default: 1,
+                },
+            },
+            required: ["contentIds"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                contentIds: z.array(z.string()).min(2),
+                connectionType: z.enum(["all", "causal", "contradictory", "complementary", "sequential"]).optional().default("all"),
+                depth: z.number().min(1).max(3).optional().default(1),
+            });
+            const params = schema.parse(args);
+            // Fetch all content items
+            const contents = await client.batchGetContent(params.contentIds, false);
+            if (!contents.results || contents.results.length < 2) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Unable to find connections. Need at least 2 valid content items.",
+                        },
+                    ],
+                    data: null,
+                };
+            }
+            // Analyze connections between content
+            const connections = analyzeConnections(contents.results, params.connectionType);
+            let responseText = `# 🔗 Content Connections Analysis\n`;
+            responseText += `**Analyzing:** ${contents.results.length} pieces of content\n`;
+            responseText += `**Connection Type:** ${params.connectionType}\n`;
+            responseText += `**Connections Found:** ${connections.length}\n\n`;
+            if (connections.length === 0) {
+                responseText += `No ${params.connectionType} connections found between the provided content.\n`;
+                responseText += `Try using connectionType='all' for broader analysis.\n`;
+            }
+            else {
+                // Group connections by type
+                const byType = groupConnectionsByType(connections);
+                Object.entries(byType).forEach(([type, conns]) => {
+                    responseText += `## ${getConnectionTypeEmoji(type)} ${type} Connections (${conns.length})\n\n`;
+                    conns.slice(0, 5).forEach((conn) => {
+                        responseText += `### ${conn.source1.title} ↔️ ${conn.source2.title}\n`;
+                        responseText += `**Relationship:** ${conn.relationship}\n`;
+                        responseText += `**Strength:** ${getStrengthIndicator(conn.strength)}\n`;
+                        if (conn.explanation) {
+                            responseText += `**Why:** ${conn.explanation}\n`;
+                        }
+                        if (conn.sharedConcepts && conn.sharedConcepts.length > 0) {
+                            responseText += `**Shared Concepts:** ${conn.sharedConcepts.join(', ')}\n`;
+                        }
+                        responseText += `\n`;
+                    });
+                });
+                // Network summary
+                responseText += `## 🌐 Connection Network Summary\n`;
+                const networkStats = calculateNetworkStats(connections, contents.results);
+                responseText += `- **Most Connected:** ${networkStats.mostConnected.title} (${networkStats.mostConnected.connectionCount} connections)\n`;
+                responseText += `- **Central Theme:** ${networkStats.centralTheme}\n`;
+                responseText += `- **Network Density:** ${networkStats.density}\n`;
+                if (params.depth > 1) {
+                    responseText += `\n## 🔍 Extended Connections (Depth ${params.depth})\n`;
+                    responseText += `*Searching for indirect connections through related content...*\n`;
+                    // This would require additional searches for related content
+                    responseText += `Use find_similar_content on highly connected items to explore further.\n`;
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: {
+                    connections,
+                    contents: contents.results,
+                    networkStats: connections.length > 0 ? calculateNetworkStats(connections, contents.results) : null,
+                },
+            };
+        },
+    },
+    {
+        name: "extract_insights",
+        description: "Extract specific types of insights across multiple content sources. Finds patterns, contradictions, consensus, or evolution of ideas.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "What insights to extract (e.g., 'productivity tips', 'AI risks', 'investment strategies')",
+                },
+                insightType: {
+                    type: "string",
+                    enum: ["patterns", "contradictions", "consensus", "evolution", "actionable", "warnings"],
+                    description: "Type of insights to extract",
+                    default: "patterns",
+                },
+                maxSources: {
+                    type: "number",
+                    description: "Maximum number of sources to analyze",
+                    default: 15,
+                },
+                minConfidence: {
+                    type: "number",
+                    description: "Minimum confidence score for insights (0-1)",
+                    default: 0.7,
+                },
+            },
+            required: ["query"],
+        },
+        modifies: false,
+        handler: async (client, args) => {
+            const schema = z.object({
+                query: z.string(),
+                insightType: z.enum(["patterns", "contradictions", "consensus", "evolution", "actionable", "warnings"]).optional().default("patterns"),
+                maxSources: z.number().optional().default(15),
+                minConfidence: z.number().min(0).max(1).optional().default(0.7),
+            });
+            const params = schema.parse(args);
+            // Search for relevant content
+            const searchResults = await client.searchContent(params.query, {
+                limit: params.maxSources,
+                enableConceptExpansion: true,
+            });
+            if (!searchResults || searchResults.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No content found for extracting insights about: "${params.query}"`,
+                        },
+                    ],
+                    data: null,
+                };
+            }
+            // Extract insights based on type
+            const insights = extractTypedInsights(searchResults, params.query, params.insightType, params.minConfidence);
+            let responseText = `# 💡 Insight Extraction: "${params.query}"\n`;
+            responseText += `**Type:** ${params.insightType} | **Sources:** ${searchResults.length} | **Min Confidence:** ${(params.minConfidence * 100).toFixed(0)}%\n\n`;
+            if (insights.length === 0) {
+                responseText += `No ${params.insightType} insights found with confidence >= ${params.minConfidence}.\n`;
+                responseText += `Try lowering the confidence threshold or using a different insight type.\n`;
+            }
+            else {
+                // Display insights by type
+                switch (params.insightType) {
+                    case "patterns":
+                        responseText += `## 🔄 Recurring Patterns\n\n`;
+                        insights.forEach((insight, idx) => {
+                            responseText += `### Pattern ${idx + 1}: ${insight.pattern}\n`;
+                            responseText += `**Frequency:** Appears in ${insight.frequency}/${searchResults.length} sources\n`;
+                            responseText += `**Confidence:** ${(insight.confidence * 100).toFixed(0)}%\n`;
+                            responseText += `**Examples:**\n`;
+                            insight.examples.slice(0, 3).forEach((ex) => {
+                                responseText += `- "${ex.text}" *(${ex.source})*\n`;
+                            });
+                            responseText += `\n`;
+                        });
+                        break;
+                    case "contradictions":
+                        responseText += `## ⚡ Contradictions & Disagreements\n\n`;
+                        insights.forEach((insight, idx) => {
+                            responseText += `### Contradiction ${idx + 1}: ${insight.topic}\n`;
+                            responseText += `**Position A:** "${insight.position1.statement}"\n`;
+                            responseText += `*Sources:* ${insight.position1.sources.join(', ')}\n\n`;
+                            responseText += `**Position B:** "${insight.position2.statement}"\n`;
+                            responseText += `*Sources:* ${insight.position2.sources.join(', ')}\n`;
+                            if (insight.resolution) {
+                                responseText += `\n**Possible Resolution:** ${insight.resolution}\n`;
+                            }
+                            responseText += `\n`;
+                        });
+                        break;
+                    case "consensus":
+                        responseText += `## ✅ Points of Consensus\n\n`;
+                        insights.forEach((insight, idx) => {
+                            responseText += `${idx + 1}. **${insight.point}**\n`;
+                            responseText += `   - Agreement: ${insight.agreementLevel}% of sources\n`;
+                            responseText += `   - Confidence: ${(insight.confidence * 100).toFixed(0)}%\n`;
+                            if (insight.nuances && insight.nuances.length > 0) {
+                                responseText += `   - Nuances: ${insight.nuances.join('; ')}\n`;
+                            }
+                        });
+                        responseText += `\n`;
+                        break;
+                    case "evolution":
+                        responseText += `## 📈 Evolution of Ideas\n\n`;
+                        insights.forEach((insight, idx) => {
+                            responseText += `### ${insight.concept}\n`;
+                            responseText += `**Timeline:**\n`;
+                            insight.timeline.forEach((point) => {
+                                responseText += `- **${point.date}:** ${point.understanding}\n`;
+                            });
+                            responseText += `**Current State:** ${insight.currentState}\n`;
+                            responseText += `**Trend:** ${insight.trend}\n\n`;
+                        });
+                        break;
+                    case "actionable":
+                        responseText += `## 🎯 Actionable Insights\n\n`;
+                        insights.forEach((insight, idx) => {
+                            responseText += `### ${idx + 1}. ${insight.action}\n`;
+                            responseText += `**Why:** ${insight.reasoning}\n`;
+                            responseText += `**Priority:** ${insight.priority}\n`;
+                            responseText += `**Evidence from:** ${insight.sources.length} sources\n`;
+                            if (insight.steps && insight.steps.length > 0) {
+                                responseText += `**Steps:**\n`;
+                                insight.steps.forEach((step, i) => {
+                                    responseText += `${i + 1}. ${step}\n`;
+                                });
+                            }
+                            responseText += `\n`;
+                        });
+                        break;
+                    case "warnings":
+                        responseText += `## ⚠️ Warnings & Risks\n\n`;
+                        insights.forEach((insight, idx) => {
+                            const severityEmoji = insight.severity === "high" ? "🔴" : insight.severity === "medium" ? "🟡" : "🟢";
+                            responseText += `### ${severityEmoji} ${insight.warning}\n`;
+                            responseText += `**Severity:** ${insight.severity}\n`;
+                            responseText += `**Mentioned in:** ${insight.sources.length} sources\n`;
+                            responseText += `**Context:** ${insight.context}\n`;
+                            if (insight.mitigation) {
+                                responseText += `**Mitigation:** ${insight.mitigation}\n`;
+                            }
+                            responseText += `\n`;
+                        });
+                        break;
+                }
+                // Summary statistics
+                responseText += `## 📊 Extraction Summary\n`;
+                responseText += `- **Total Insights:** ${insights.length}\n`;
+                responseText += `- **Average Confidence:** ${(insights.reduce((sum, i) => sum + i.confidence, 0) / insights.length * 100).toFixed(0)}%\n`;
+                responseText += `- **Sources Analyzed:** ${searchResults.length}\n`;
+                const contributingSources = new Set(insights.flatMap((i) => i.sources || []));
+                responseText += `- **Contributing Sources:** ${contributingSources.size}\n`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+                data: {
+                    query: params.query,
+                    insightType: params.insightType,
+                    insights,
+                    sources: searchResults,
+                },
+            };
+        },
+    },
+];
+// Helper functions for the new tools
+function chunkContent(text, targetTokenSize, maxTokens) {
+    const words = text.split(/\s+/);
+    const wordsPerChunk = Math.floor(targetTokenSize / 1.3); // Rough token estimation
+    const chunks = [];
+    let totalTokens = 0;
+    for (let i = 0; i < words.length; i += wordsPerChunk) {
+        const chunkWords = words.slice(i, i + wordsPerChunk);
+        const chunkText = chunkWords.join(' ');
+        const chunkTokens = Math.ceil(chunkWords.length * 1.3);
+        // Stop if we've reached the max token limit
+        if (maxTokens && totalTokens + chunkTokens > maxTokens) {
+            break;
+        }
+        chunks.push({
+            index: chunks.length,
+            text: chunkText,
+            tokenCount: chunkTokens,
+            startOffset: i,
+            endOffset: Math.min(i + wordsPerChunk, words.length),
+        });
+        totalTokens += chunkTokens;
+    }
+    return chunks;
+}
+function detectSections(text, contentType) {
+    const sections = [];
+    // Simple section detection based on headers and paragraphs
+    const lines = text.split('\n');
+    let currentSection = { title: "Introduction", text: "", type: "intro", tokenCount: 0 };
+    for (const line of lines) {
+        // Detect headers (various formats)
+        if (line.match(/^#{1,6}\s+/) || line.match(/^[A-Z][^.!?]*:$/) || (line.length < 100 && line.match(/^[A-Z]/))) {
+            if (currentSection.text) {
+                currentSection.tokenCount = Math.ceil(currentSection.text.split(/\s+/).length * 1.3);
+                sections.push(currentSection);
+            }
+            currentSection = {
+                title: line.replace(/^#+\s+/, '').replace(/:$/, ''),
+                text: "",
+                type: "section",
+                tokenCount: 0,
+            };
+        }
+        else {
+            currentSection.text += line + "\n";
+        }
+    }
+    // Add the last section
+    if (currentSection.text) {
+        currentSection.tokenCount = Math.ceil(currentSection.text.split(/\s+/).length * 1.3);
+        sections.push(currentSection);
+    }
+    return sections;
+}
+function extractKeyConceptsFromSearch(results, topic) {
+    const concepts = new Map();
+    results.forEach(result => {
+        // Extract from tags
+        if (result.tags) {
+            result.tags.forEach((tag) => {
+                concepts.set(tag, (concepts.get(tag) || 0) + 2);
+            });
+        }
+        // Extract from summary
+        if (result.summary) {
+            const summary = typeof result.summary === 'string' ? result.summary : result.summary.one_sentence;
+            if (summary) {
+                // Simple concept extraction from summary
+                const words = summary.toLowerCase().split(/\s+/);
+                const importantWords = words.filter((w) => w.length > 5 && !['about', 'through', 'between', 'during'].includes(w));
+                importantWords.forEach((word) => {
+                    concepts.set(word, (concepts.get(word) || 0) + 1);
+                });
+            }
+        }
+    });
+    // Sort by frequency and return top concepts
+    return Array.from(concepts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([concept]) => concept)
+        .filter(concept => concept.toLowerCase() !== topic.toLowerCase());
+}
+function groupByPerspective(results) {
+    const perspectives = {};
+    results.forEach(result => {
+        // Group by content type as a simple perspective grouping
+        const perspective = result.contentType || 'general';
+        if (!perspectives[perspective]) {
+            perspectives[perspective] = [];
+        }
+        perspectives[perspective].push(result);
+    });
+    return perspectives;
+}
+function createTopicTimeline(results) {
+    // Sort by date and create timeline
+    const sorted = results
+        .filter(r => r.createdAt)
+        .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    return sorted.slice(0, 5).map(result => ({
+        date: new Date(result.createdAt).toLocaleDateString(),
+        title: result.title || "Untitled",
+        insight: typeof result.summary === 'string'
+            ? result.summary.slice(0, 100)
+            : result.summary?.one_sentence?.slice(0, 100) || "No summary",
+    }));
+}
+function createLearningPath(results, topic) {
+    // Create a simple learning path based on content
+    const path = [];
+    // Find introductory content
+    const intro = results.find(r => r.title?.toLowerCase().includes('introduction') ||
+        r.title?.toLowerCase().includes('basics') ||
+        r.title?.toLowerCase().includes('beginner'));
+    if (intro) {
+        path.push({
+            title: intro.title || "Introduction",
+            reason: "Start with foundational concepts",
+            id: intro.id,
+        });
+    }
+    // Add the most relevant content
+    results
+        .filter(r => r.id !== intro?.id)
+        .slice(0, 3)
+        .forEach(result => {
+        path.push({
+            title: result.title || "Untitled",
+            reason: "Build on core concepts",
+            id: result.id,
+        });
+    });
+    return path;
+}
+function analyzeConnections(contents, connectionType) {
+    const connections = [];
+    // Analyze pairs of content
+    for (let i = 0; i < contents.length; i++) {
+        for (let j = i + 1; j < contents.length; j++) {
+            const conn = findConnection(contents[i], contents[j], connectionType);
+            if (conn) {
+                connections.push(conn);
+            }
+        }
+    }
+    return connections;
+}
+function findConnection(content1, content2, type) {
+    // Simple connection detection based on shared concepts
+    const tags1 = new Set(content1.tags || []);
+    const tags2 = new Set(content2.tags || []);
+    const sharedTags = Array.from(tags1).filter(t => tags2.has(t));
+    if (sharedTags.length === 0 && type !== "contradictory") {
+        return null;
+    }
+    return {
+        source1: { id: content1.id, title: content1.title || "Untitled" },
+        source2: { id: content2.id, title: content2.title || "Untitled" },
+        type: sharedTags.length > 2 ? "strong" : "weak",
+        relationship: sharedTags.length > 0 ? "complementary" : "independent",
+        strength: sharedTags.length / Math.max(tags1.size, tags2.size),
+        sharedConcepts: sharedTags,
+        explanation: `Share ${sharedTags.length} common concepts`,
+    };
+}
+function groupConnectionsByType(connections) {
+    const grouped = {};
+    connections.forEach(conn => {
+        const type = conn.relationship || "unknown";
+        if (!grouped[type]) {
+            grouped[type] = [];
+        }
+        grouped[type].push(conn);
+    });
+    return grouped;
+}
+function getConnectionTypeEmoji(type) {
+    const emojis = {
+        complementary: "🤝",
+        contradictory: "⚡",
+        causal: "➡️",
+        sequential: "📅",
+        independent: "🔀",
+    };
+    return emojis[type] || "🔗";
+}
+function getStrengthIndicator(strength) {
+    if (strength > 0.8)
+        return "🟢🟢🟢 Very Strong";
+    if (strength > 0.6)
+        return "🟢🟢 Strong";
+    if (strength > 0.4)
+        return "🟡 Moderate";
+    if (strength > 0.2)
+        return "🟠 Weak";
+    return "🔴 Very Weak";
+}
+function calculateNetworkStats(connections, contents) {
+    const connectionCounts = new Map();
+    connections.forEach(conn => {
+        const id1 = conn.source1.id;
+        const id2 = conn.source2.id;
+        connectionCounts.set(id1, (connectionCounts.get(id1) || 0) + 1);
+        connectionCounts.set(id2, (connectionCounts.get(id2) || 0) + 1);
+    });
+    const mostConnectedId = Array.from(connectionCounts.entries())
+        .sort((a, b) => b[1] - a[1])[0]?.[0];
+    const mostConnected = contents.find(c => c.id === mostConnectedId) || contents[0];
+    return {
+        mostConnected: {
+            title: mostConnected?.title || "Unknown",
+            connectionCount: connectionCounts.get(mostConnectedId) || 0,
+        },
+        centralTheme: connections[0]?.sharedConcepts?.[0] || "Unknown",
+        density: connections.length > 0 ? "High" : "Low",
+    };
+}
+function extractTypedInsights(results, query, type, minConfidence) {
+    // Simplified insight extraction
+    const insights = [];
+    switch (type) {
+        case "patterns":
+            // Find recurring themes
+            const themes = new Map();
+            results.forEach(result => {
+                if (result.tags) {
+                    result.tags.forEach((tag) => {
+                        if (!themes.has(tag))
+                            themes.set(tag, []);
+                        themes.get(tag).push(result);
+                    });
+                }
+            });
+            Array.from(themes.entries())
+                .filter(([_, sources]) => sources.length >= 2)
+                .forEach(([theme, sources]) => {
+                insights.push({
+                    pattern: theme,
+                    frequency: sources.length,
+                    confidence: sources.length / results.length,
+                    examples: sources.slice(0, 3).map(s => ({
+                        text: s.title || "Untitled",
+                        source: s.contentType,
+                    })),
+                });
+            });
+            break;
+        case "actionable":
+            // Extract actionable items from summaries
+            results.forEach(result => {
+                if (result.summary && typeof result.summary === 'object' && result.summary.actionable_takeaways) {
+                    result.summary.actionable_takeaways.forEach((action) => {
+                        insights.push({
+                            action,
+                            reasoning: "Extracted from content analysis",
+                            priority: "medium",
+                            sources: [result],
+                            confidence: 0.8,
+                        });
+                    });
+                }
+            });
+            break;
+        default:
+            // Generic insight extraction
+            results.slice(0, 5).forEach(result => {
+                if (result.summary) {
+                    insights.push({
+                        text: typeof result.summary === 'string' ? result.summary : result.summary.one_sentence,
+                        source: result.title || "Untitled",
+                        confidence: 0.75,
+                    });
+                }
+            });
+    }
+    return insights.filter((i) => i.confidence >= minConfidence);
+}
+//# sourceMappingURL=index-old.js.map