@contextstream/mcp-server 0.3.41 → 0.3.43

package/README.md

@@ -91,6 +91,8 @@ These clients use the `mcpServers` JSON schema:
 
 Many other MCP JSON clients also use this same `mcpServers` shape (including Claude Code project scope via `.mcp.json`).
 
+**Core toolset (default, ~17 tools):**
+
 ```json
 {
   "mcpServers": {
@@ -106,10 +108,30 @@ Many other MCP JSON clients also use this same `mcpServers` shape (including Cla
 }
 ```
 
+**Full toolset (~86 tools):**
+
+```json
+{
+  "mcpServers": {
+    "contextstream": {
+      "command": "npx",
+      "args": ["-y", "@contextstream/mcp-server"],
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_api_key",
+        "CONTEXTSTREAM_TOOLSET": "full"
+      }
+    }
+  }
+}
+```
+
 ### VS Code (`.vscode/mcp.json`)
 
 VS Code uses a different schema with a top-level `servers` map:
 
+**Core toolset (default):**
+
 ```json
 {
   "servers": {
@@ -126,6 +148,25 @@ VS Code uses a different schema with a top-level `servers` map:
 }
 ```
 
+**Full toolset (~86 tools):**
+
+```json
+{
+  "servers": {
+    "contextstream": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@contextstream/mcp-server"],
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_api_key",
+        "CONTEXTSTREAM_TOOLSET": "full"
+      }
+    }
+  }
+}
+```
+
 Strong recommendation: VS Code supports `inputs` so you don’t have to hardcode secrets in a committed file:
 
 ```json
@@ -156,28 +197,59 @@ Strong recommendation: VS Code supports `inputs` so you don’t have to hardcode
 
 User scope (all projects):
 
+**Core toolset (recommended for Claude Code):**
+
+```bash
+claude mcp add --transport stdio contextstream --scope user \
+  --env CONTEXTSTREAM_API_URL=https://api.contextstream.io \
+  --env CONTEXTSTREAM_API_KEY=YOUR_KEY \
+  -- npx -y @contextstream/mcp-server
+```
+
+**Full toolset (~86 tools):**
+
 ```bash
 claude mcp add --transport stdio contextstream --scope user \
   --env CONTEXTSTREAM_API_URL=https://api.contextstream.io \
   --env CONTEXTSTREAM_API_KEY=YOUR_KEY \
-  --env CONTEXTSTREAM_TOOLSET=core -- \
-  npx -y @contextstream/mcp-server
+  --env CONTEXTSTREAM_TOOLSET=full \
+  -- npx -y @contextstream/mcp-server
 ```
 
-Tip: Claude Code warns on large tool contexts. The default toolset is `core`.
-Set `CONTEXTSTREAM_TOOLSET=full` to expose everything.
+Note: Claude Code may warn about large tool contexts when using `full`. The default is `core` (~17 tools).
+
+Windows caveat (native Windows, not WSL): if `npx` isn't found, use `cmd /c npx -y @contextstream/mcp-server` after `--`.
 
-Windows caveat (native Windows, not WSL): if `npx` isn’t found, use `cmd /c npx -y @contextstream/mcp-server` after `--`.
+**Alternative (JSON form):**
 
-Alternative (JSON form):
+Core:
+```bash
+claude mcp add-json contextstream \
+'{"type":"stdio","command":"npx","args":["-y","@contextstream/mcp-server"],"env":{"CONTEXTSTREAM_API_URL":"https://api.contextstream.io","CONTEXTSTREAM_API_KEY":"your_api_key"}}'
+```
 
+Full:
 ```bash
 claude mcp add-json contextstream \
-'{"type":"stdio","command":"npx","args":["-y","@contextstream/mcp-server"],"env":{"CONTEXTSTREAM_API_URL":"https://api.contextstream.io","CONTEXTSTREAM_API_KEY":"your_api_key","CONTEXTSTREAM_TOOLSET":"core"}}'
+'{"type":"stdio","command":"npx","args":["-y","@contextstream/mcp-server"],"env":{"CONTEXTSTREAM_API_URL":"https://api.contextstream.io","CONTEXTSTREAM_API_KEY":"your_api_key","CONTEXTSTREAM_TOOLSET":"full"}}'
 ```
 
 ### Codex CLI (`~/.codex/config.toml`)
 
+**Core toolset (default):**
+
+```toml
+[mcp_servers.contextstream]
+command = "npx"
+args = ["-y", "@contextstream/mcp-server"]
+
+[mcp_servers.contextstream.env]
+CONTEXTSTREAM_API_URL = "https://api.contextstream.io"
+CONTEXTSTREAM_API_KEY = "your_api_key"
+```
+
+**Full toolset (~86 tools):**
+
 ```toml
 [mcp_servers.contextstream]
 command = "npx"
@@ -186,6 +258,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "https://api.contextstream.io"
 CONTEXTSTREAM_API_KEY = "your_api_key"
+CONTEXTSTREAM_TOOLSET = "full"
 ```
 
 After editing, restart your MCP client so it reloads the server configuration.

package/dist/index.js

@@ -6923,6 +6923,80 @@ W:${wsHint}
     }
     return request(this.config, `/workspaces/${withDefaults.workspace_id}/integrations/status`, { method: "GET" });
   }
+  /**
+   * Get GitHub summary for a workspace
+   */
+  async githubSummary(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub summary");
+    }
+    const query = new URLSearchParams();
+    if (params?.days) query.set("days", String(params.days));
+    if (params?.repo) query.set("repo", params.repo);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/github/summary${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get Slack summary for a workspace
+   */
+  async slackSummary(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack summary");
+    }
+    const query = new URLSearchParams();
+    if (params?.days) query.set("days", String(params.days));
+    if (params?.channel) query.set("channel", params.channel);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/slack/summary${suffix}`, { method: "GET" });
+  }
+  /**
+   * Cross-source search across all integrations
+   */
+  async integrationsSearch(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for integrations search");
+    }
+    const urlParams = new URLSearchParams();
+    urlParams.set("q", params.query);
+    urlParams.set("workspace_id", withDefaults.workspace_id);
+    if (params?.limit) urlParams.set("limit", String(params.limit));
+    if (params?.sources) urlParams.set("sources", params.sources.join(","));
+    if (params?.days) urlParams.set("days", String(params.days));
+    if (params?.sort_by) urlParams.set("sort_by", params.sort_by);
+    return request(this.config, `/integrations/search?${urlParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Cross-source summary across all integrations
+   */
+  async integrationsSummary(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for integrations summary");
+    }
+    const query = new URLSearchParams();
+    query.set("workspace_id", withDefaults.workspace_id);
+    if (params?.days) query.set("days", String(params.days));
+    return request(this.config, `/integrations/summary?${query.toString()}`, { method: "GET" });
+  }
+  /**
+   * Cross-source knowledge from all integrations
+   */
+  async integrationsKnowledge(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for integrations knowledge");
+    }
+    const urlParams = new URLSearchParams();
+    urlParams.set("workspace_id", withDefaults.workspace_id);
+    if (params?.knowledge_type) urlParams.set("knowledge_type", params.knowledge_type);
+    if (params?.query) urlParams.set("query", params.query);
+    if (params?.sources) urlParams.set("sources", params.sources.join(","));
+    if (params?.limit) urlParams.set("limit", String(params.limit));
+    return request(this.config, `/integrations/knowledge?${urlParams.toString()}`, { method: "GET" });
+  }
 };
 
 // src/tools.ts
@@ -7026,6 +7100,16 @@ var CONTEXTSTREAM_TOOL_NAMES = [
   "slack_discussions",
   "slack_search",
   "slack_sync_users",
+  "slack_knowledge",
+  "slack_summary",
+  // GitHub additional
+  "github_knowledge",
+  "github_summary",
+  // Cross-source integrations
+  "integrations_status",
+  "integrations_search",
+  "integrations_summary",
+  "integrations_knowledge",
   // Auth/Meta
   "auth_me",
   "mcp_server_version"
@@ -7194,7 +7278,18 @@ session_recall(query="what did we decide about caching?")
 
 ### Full Tool Catalog
 
-The following tools are available when \`CONTEXTSTREAM_TOOLSET=full\` (default is \`core\`, which includes only the essential session/context tools above):
+To expose all tools below, set \`CONTEXTSTREAM_TOOLSET=full\` in your MCP config. The default (\`core\`) includes only the essential session/context tools above.
+
+**To enable full toolset in your MCP config:**
+\`\`\`json
+{
+  "env": {
+    "CONTEXTSTREAM_TOOLSET": "full"
+  }
+}
+\`\`\`
+
+**Available tool categories (when \`CONTEXTSTREAM_TOOLSET=full\`):**
 
 **Session/Context** (included in core):
 \`session_init\`, \`context_smart\`, \`session_summary\`, \`session_capture\`, \`session_capture_lesson\`, \`session_get_lessons\`, \`session_recall\`, \`session_remember\`, \`session_get_user_context\`, \`session_smart_search\`, \`session_compress\`, \`session_delta\`, \`generate_editor_rules\`, \`workspace_associate\`, \`workspace_bootstrap\`
@@ -7218,10 +7313,13 @@ The following tools are available when \`CONTEXTSTREAM_TOOLSET=full\` (default i
 \`ai_context\`, \`ai_enhanced_context\`, \`ai_context_budget\`, \`ai_embeddings\`, \`ai_plan\`, \`ai_tasks\`
 
 **GitHub Integration** (PRO):
-\`github_stats\`, \`github_repos\`, \`github_contributors\`, \`github_activity\`, \`github_issues\`, \`github_search\`
+\`github_stats\`, \`github_repos\`, \`github_contributors\`, \`github_activity\`, \`github_issues\`, \`github_search\`, \`github_knowledge\`, \`github_summary\`
 
 **Slack Integration** (PRO):
-\`slack_stats\`, \`slack_channels\`, \`slack_contributors\`, \`slack_activity\`, \`slack_discussions\`, \`slack_search\`, \`slack_sync_users\`
+\`slack_stats\`, \`slack_channels\`, \`slack_contributors\`, \`slack_activity\`, \`slack_discussions\`, \`slack_search\`, \`slack_sync_users\`, \`slack_knowledge\`, \`slack_summary\`
+
+**Cross-Source Integrations** (PRO):
+\`integrations_status\`, \`integrations_search\`, \`integrations_summary\`, \`integrations_knowledge\`
 
 See full documentation: https://contextstream.io/docs/mcp/tools
 `.trim();
@@ -7235,7 +7333,20 @@ var CONTEXTSTREAM_RULES_MINIMAL = `
 - For code/file discovery, use \`session_smart_search\` before raw repo scans (\`rg\`, \`ls\`, \`find\`); fall back only if needed.
 - After meaningful work/decisions/preferences: \`session_capture(event_type=decision|preference|task|insight, title="\u2026", content="\u2026")\`.
 - On frustration/corrections/tool mistakes: \`session_capture_lesson(...)\`.
-- Full tool catalog (workspaces, projects, search, memory, graph, AI, integrations): see https://contextstream.io/docs/mcp/tools
+
+### Tool Catalog
+
+By default, the MCP server exposes **core** tools (~17 essential session/context tools). To expose the **full** catalog (~86 tools including workspaces, projects, search, memory, graph, AI, and integrations), set \`CONTEXTSTREAM_TOOLSET=full\` in your MCP config:
+
+\`\`\`json
+{
+  "env": {
+    "CONTEXTSTREAM_TOOLSET": "full"
+  }
+}
+\`\`\`
+
+Full tool reference: https://contextstream.io/docs/mcp/tools
 `.trim();
 var TEMPLATES = {
   codex: {
@@ -7332,11 +7443,155 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
   };
 }
 
+// src/tool-catalog.ts
+var TOOL_CATALOG = [
+  {
+    name: "Session",
+    tools: [
+      { name: "init", hint: "start-conv" },
+      { name: "smart", hint: "each-msg" },
+      { name: "capture", hint: "save" },
+      { name: "recall", hint: "find" },
+      { name: "remember", hint: "quick" },
+      { name: "compress", hint: "end" },
+      { name: "summary", hint: "brief" },
+      { name: "delta", hint: "changes" },
+      { name: "get_lessons", hint: "learn" },
+      { name: "capture_lesson", hint: "mistake" },
+      { name: "get_user_context", hint: "prefs" },
+      { name: "smart_search", hint: "deep-find" }
+    ]
+  },
+  {
+    name: "Search",
+    tools: [
+      { name: "semantic", hint: "meaning" },
+      { name: "hybrid", hint: "combo" },
+      { name: "keyword", hint: "exact" },
+      { name: "pattern", hint: "code" }
+    ]
+  },
+  {
+    name: "Memory",
+    tools: [
+      { name: "create_event", hint: "new" },
+      { name: "list_events", hint: "list" },
+      { name: "get_event", hint: "get" },
+      { name: "update_event", hint: "edit" },
+      { name: "delete_event", hint: "rm" },
+      { name: "search", hint: "find" },
+      { name: "decisions", hint: "choices" },
+      { name: "timeline", hint: "history" },
+      { name: "distill_event", hint: "extract" }
+    ]
+  },
+  {
+    name: "Knowledge",
+    tools: [
+      { name: "create_node", hint: "new" },
+      { name: "list_nodes", hint: "list" },
+      { name: "get_node", hint: "get" },
+      { name: "update_node", hint: "edit" },
+      { name: "delete_node", hint: "rm" },
+      { name: "supersede_node", hint: "replace" }
+    ]
+  },
+  {
+    name: "Graph",
+    tools: [
+      { name: "related", hint: "links" },
+      { name: "path", hint: "trace" },
+      { name: "decisions", hint: "choices" },
+      { name: "dependencies", hint: "deps" },
+      { name: "impact", hint: "changes" },
+      { name: "contradictions", hint: "conflicts" }
+    ]
+  },
+  {
+    name: "Workspace",
+    tools: [
+      { name: "list", hint: "" },
+      { name: "get", hint: "" },
+      { name: "create", hint: "" },
+      { name: "associate", hint: "link-folder" },
+      { name: "bootstrap", hint: "new-ws" }
+    ]
+  },
+  {
+    name: "Project",
+    tools: [
+      { name: "list", hint: "" },
+      { name: "get", hint: "" },
+      { name: "create", hint: "" },
+      { name: "index", hint: "scan-code" },
+      { name: "files", hint: "list-files" },
+      { name: "overview", hint: "summary" }
+    ]
+  },
+  {
+    name: "AI",
+    tools: [
+      { name: "context", hint: "smart-ctx" },
+      { name: "plan", hint: "generate" },
+      { name: "tasks", hint: "breakdown" },
+      { name: "embeddings", hint: "vectors" }
+    ]
+  }
+];
+function generateToolCatalog(format = "grouped", category) {
+  let categories = TOOL_CATALOG;
+  if (category) {
+    const filtered = TOOL_CATALOG.filter(
+      (c) => c.name.toLowerCase() === category.toLowerCase()
+    );
+    if (filtered.length > 0) {
+      categories = filtered;
+    }
+  }
+  switch (format) {
+    case "minimal":
+      return generateMinimal(categories);
+    case "full":
+      return generateFull(categories);
+    case "grouped":
+    default:
+      return generateGrouped(categories);
+  }
+}
+function generateGrouped(categories) {
+  return categories.map((cat) => {
+    const tools = cat.tools.map((t) => t.hint ? `${t.name}(${t.hint})` : t.name).join(" ");
+    return `${cat.name}: ${tools}`;
+  }).join("\n");
+}
+function generateMinimal(categories) {
+  return categories.map((cat) => {
+    const tools = cat.tools.map((t) => t.name).join("|");
+    return `${cat.name}:${tools}`;
+  }).join("\n");
+}
+function generateFull(categories) {
+  const lines = [];
+  for (const cat of categories) {
+    lines.push(`## ${cat.name}`);
+    for (const tool of cat.tools) {
+      const prefix = cat.name.toLowerCase().replace(/\s+/g, "_");
+      const fullName = `${prefix}_${tool.name}`;
+      lines.push(`- ${fullName}: ${tool.hint || "standard CRUD"}`);
+    }
+  }
+  return lines.join("\n");
+}
+function getCoreToolsHint() {
+  return `Session: init(start) smart(each-msg) capture(save) recall(find) remember(quick)`;
+}
+
 // src/tools.ts
 var LESSON_DEDUP_WINDOW_MS = 2 * 60 * 1e3;
 var recentLessonCaptures = /* @__PURE__ */ new Map();
 var CORE_TOOLSET = /* @__PURE__ */ new Set([
   "session_init",
+  "session_tools",
   "context_smart",
   "session_summary",
   "session_capture",
@@ -8577,6 +8832,7 @@ This does semantic search on the first message. You only need context_smart on s
         ideRoots = [input.folder_path];
       }
       const result = await client.initSession(input, ideRoots);
+      result.tools_hint = getCoreToolsHint();
       if (sessionManager) {
         sessionManager.markInitialized(result);
       }
@@ -8632,6 +8888,38 @@ This does semantic search on the first message. You only need context_smart on s
       return { content: [{ type: "text", text }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "session_tools",
+    {
+      title: "Get available ContextStream tools",
+      description: `Get an ultra-compact list of all available ContextStream MCP tools.
+Use this when you need to know what tools are available without reading full descriptions.
+
+Returns a token-efficient tool catalog (~120 tokens) organized by category.
+
+Format options:
+- 'grouped' (default): Category: tool(hint) tool(hint) - best for quick reference
+- 'minimal': Category:tool|tool|tool - most compact
+- 'full': Detailed list with descriptions
+
+Example output (grouped):
+Session: init(start-conv) smart(each-msg) capture(save) recall(find) remember(quick)
+Search: semantic(meaning) hybrid(combo) keyword(exact)
+Memory: events(crud) nodes(knowledge) search(find) decisions(choices)`,
+      inputSchema: external_exports.object({
+        format: external_exports.enum(["grouped", "minimal", "full"]).optional().default("grouped").describe("Output format: grouped (default, ~120 tokens), minimal (~80 tokens), or full (~200 tokens)"),
+        category: external_exports.string().optional().describe("Filter to specific category: Session, Search, Memory, Knowledge, Graph, Workspace, Project, AI")
+      })
+    },
+    async (input) => {
+      const format = input.format || "grouped";
+      const catalog = generateToolCatalog(format, input.category);
+      return {
+        content: [{ type: "text", text: catalog }],
+        structuredContent: { format, catalog }
+      };
+    }
+  );
   registerTool(
     "session_get_user_context",
     {
@@ -9884,6 +10172,169 @@ Example queries:
       return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "github_summary",
+    {
+      title: "GitHub activity summary",
+      description: `Get a high-level summary of GitHub activity for a workspace.
+Returns: overview of issues, PRs, commits, releases, and highlights for the specified period.
+Use this for weekly/monthly reports or to get a quick overview of repository activity.
+
+Example prompts:
+- "Give me a weekly GitHub summary"
+- "What happened in GitHub last month?"
+- "Show me the GitHub summary for repo X"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        days: external_exports.number().optional().describe("Number of days to summarize (default: 7)"),
+        repo: external_exports.string().optional().describe("Filter by repository name")
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubSummary({
+        workspace_id: workspaceId,
+        days: input.days,
+        repo: input.repo
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "slack_summary",
+    {
+      title: "Slack activity summary",
+      description: `Get a high-level summary of Slack activity for a workspace.
+Returns: overview of messages, threads, top channels, and highlights for the specified period.
+Use this for weekly/monthly reports or to get a quick overview of team discussions.
+
+Example prompts:
+- "Give me a weekly Slack summary"
+- "What was discussed in Slack last month?"
+- "Show me the Slack summary for #engineering"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        days: external_exports.number().optional().describe("Number of days to summarize (default: 7)"),
+        channel: external_exports.string().optional().describe("Filter by channel name")
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackSummary({
+        workspace_id: workspaceId,
+        days: input.days,
+        channel: input.channel
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "integrations_search",
+    {
+      title: "Cross-source search",
+      description: `Search across all connected integrations (GitHub, Slack, etc.) with a single query.
+Returns: unified results from all sources, ranked by relevance or recency.
+Use this to find related discussions, issues, and content across all your tools.
+
+Example prompts:
+- "Search all integrations for database migration discussions"
+- "Find mentions of authentication across GitHub and Slack"
+- "Search for API changes in the last 30 days"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        query: external_exports.string().describe("Search query"),
+        limit: external_exports.number().optional().describe("Maximum results (default: 20)"),
+        sources: external_exports.array(external_exports.string()).optional().describe("Filter by source: github, slack"),
+        days: external_exports.number().optional().describe("Filter to results within N days"),
+        sort_by: external_exports.enum(["relevance", "recent", "engagement"]).optional().describe("Sort by: relevance, recent, or engagement")
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.integrationsSearch({
+        workspace_id: workspaceId,
+        query: input.query,
+        limit: input.limit,
+        sources: input.sources,
+        days: input.days,
+        sort_by: input.sort_by
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "integrations_summary",
+    {
+      title: "Cross-source activity summary",
+      description: `Get a unified summary of activity across all connected integrations.
+Returns: combined overview of GitHub and Slack activity, key highlights, and trends.
+Use this for weekly team summaries or to understand overall activity across all tools.
+
+Example prompts:
+- "Give me a weekly team summary across all sources"
+- "What happened across GitHub and Slack last week?"
+- "Show me a unified activity overview"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        days: external_exports.number().optional().describe("Number of days to summarize (default: 7)")
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.integrationsSummary({
+        workspace_id: workspaceId,
+        days: input.days
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "integrations_knowledge",
+    {
+      title: "Cross-source knowledge",
+      description: `Get knowledge extracted from all connected integrations (GitHub, Slack, etc.).
+Returns: decisions, lessons, and insights distilled from all sources.
+Use this to find key decisions and learnings from across your team's conversations.
+
+Example prompts:
+- "What decisions were made across all sources about authentication?"
+- "Show me lessons learned from all integrations"
+- "What insights have we gathered from GitHub and Slack?"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        knowledge_type: external_exports.enum(["decision", "lesson", "fact", "insight"]).optional().describe("Filter by knowledge type"),
+        query: external_exports.string().optional().describe("Optional search query to filter knowledge"),
+        sources: external_exports.array(external_exports.string()).optional().describe("Filter by source: github, slack"),
+        limit: external_exports.number().optional().describe("Maximum items to return (default: 20)")
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.integrationsKnowledge({
+        workspace_id: workspaceId,
+        knowledge_type: input.knowledge_type,
+        query: input.query,
+        sources: input.sources,
+        limit: input.limit
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
   registerTool(
     "integrations_status",
     {
@@ -10501,6 +10952,8 @@ async function upsertCodexTomlConfig(filePath, params) {
   const existing = exists ? await fs5.readFile(filePath, "utf8").catch(() => "") : "";
   const marker = "[mcp_servers.contextstream]";
   const envMarker = "[mcp_servers.contextstream.env]";
+  const toolsetLine = params.toolset ? `CONTEXTSTREAM_TOOLSET = "${params.toolset}"
+` : "";
   const block = `
 
 # ContextStream MCP server
@@ -10511,7 +10964,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-`;
+` + toolsetLine;
   if (!exists) {
     await fs5.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
@@ -10782,8 +11235,13 @@ Created API key: ${maskApiKey(apiKey)}
     const mode = modeChoice === "2" ? "full" : "minimal";
     console.log("\nMCP toolset (which tools to expose to the AI):");
     console.log("  1) Core (recommended) \u2014 essential session/context tools (~17 tools, lower token overhead)");
+    console.log("     Best for: most users, Claude Code, Claude Desktop (avoids large-context warnings)");
     console.log("  2) Full \u2014 all tools including workspaces, projects, search, memory, graph, AI, integrations (~86 tools)");
+    console.log("     Best for: power users needing direct access to all workspace/project/graph/AI tools");
     console.log("     Note: Claude Code/Desktop may warn about large tool lists when using full toolset.");
+    console.log("");
+    console.log("  Tip: You can switch toolsets later by editing the MCP config and setting CONTEXTSTREAM_TOOLSET=full");
+    console.log("       See https://contextstream.io/docs/mcp/tools for the full tool catalog.");
     const toolsetChoice = normalizeInput(await rl.question("Choose [1/2] (default 1): ")) || "1";
     const toolset = toolsetChoice === "2" ? "full" : "core";
     const editors = ["codex", "claude", "cursor", "windsurf", "cline", "kilo", "roo", "aider"];
@@ -10832,7 +11290,8 @@ Created API key: ${maskApiKey(apiKey)}
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
               continue;
             }
-            const status = await upsertCodexTomlConfig(filePath, { apiUrl, apiKey });
+            const codexParams = toolset === "full" ? { apiUrl, apiKey, toolset: "full" } : { apiUrl, apiKey };
+            const status = await upsertCodexTomlConfig(filePath, codexParams);
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextstream/mcp-server",
-  "version": "0.3.41",
+  "version": "0.3.43",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",