@contextstream/mcp-server 0.3.40 → 0.3.42

package/README.md

@@ -48,9 +48,10 @@ npx -y @contextstream/mcp-server setup
 
 Notes:
 - Uses browser/device login by default and creates an API key for you.
+- Prompts for **toolset selection**: `core` (default, ~17 essential tools) or `full` (~86 tools including workspaces, projects, search, memory, graph, AI, and integrations).
 - To avoid re-auth prompts on subsequent runs, the wizard saves that API key to `~/.contextstream/credentials.json` (and also writes it into the MCP config files it generates). Delete that file to force a fresh login.
 - Codex CLI MCP config is global-only (`~/.codex/config.toml`), so the wizard will always write Codex config globally when selected.
-- Some tools still require UI/CLI-based MCP setup (the wizard will tell you when it can’t write a config).
+- Some tools still require UI/CLI-based MCP setup (the wizard will tell you when it can't write a config).
 - Preview changes without writing files: `npx -y @contextstream/mcp-server setup --dry-run`
 
 ### Run the server
@@ -74,7 +75,9 @@ contextstream-mcp
 
 If you ran the [setup wizard](#setup-wizard-recommended), you can usually skip this section.
 
-If you prefer to configure things by hand (or your tool can’t be auto-configured), add the ContextStream MCP server to your client using one of the examples below.
+If you prefer to configure things by hand (or your tool can't be auto-configured), add the ContextStream MCP server to your client using one of the examples below.
+
+**Toolset**: By default, the server exposes `core` tools (~17 essential session/context tools). To expose all ~86 tools (workspaces, projects, search, memory, graph, AI, integrations), add `"CONTEXTSTREAM_TOOLSET": "full"` to the `env` block. See the [full tool catalog](https://contextstream.io/docs/mcp/tools).
 
 ### Cursor / Windsurf / Claude Desktop (JSON)
 
@@ -88,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": {
@@ -103,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": {
@@ -123,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
@@ -153,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 \
-  --env CONTEXTSTREAM_TOOLSET=core -- \
-  npx -y @contextstream/mcp-server
+  -- 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.
+**Full toolset (~86 tools):**
 
-Windows caveat (native Windows, not WSL): if `npx` isn’t found, use `cmd /c npx -y @contextstream/mcp-server` after `--`.
+```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=full \
+  -- npx -y @contextstream/mcp-server
+```
+
+Note: Claude Code may warn about large tool contexts when using `full`. The default is `core` (~17 tools).
 
-Alternative (JSON form):
+Windows caveat (native Windows, not WSL): if `npx` isn't found, use `cmd /c npx -y @contextstream/mcp-server` after `--`.
 
+**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","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"}}'
+```
+
+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":"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"
@@ -183,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.
@@ -204,7 +280,7 @@ You can authenticate using either:
 | `CONTEXTSTREAM_WORKSPACE_ID` | No | Default workspace ID fallback |
 | `CONTEXTSTREAM_PROJECT_ID` | No | Default project ID fallback |
 | `CONTEXTSTREAM_USER_AGENT` | No | Custom user agent string |
-| `CONTEXTSTREAM_TOOLSET` | No | Tool bundle to expose (`core` default, or `full`) |
+| `CONTEXTSTREAM_TOOLSET` | No | Tool bundle to expose: `core` (default, ~17 tools) or `full` (~86 tools). Claude Code/Desktop may warn about large tool contexts with `full`. |
 | `CONTEXTSTREAM_TOOL_ALLOWLIST` | No | Comma-separated tool names to expose (overrides toolset) |
 | `CONTEXTSTREAM_PRO_TOOLS` | No | Comma-separated tool names treated as PRO (default: `ai_context,ai_enhanced_context,ai_context_budget,ai_embeddings,ai_plan,ai_tasks`) |
 | `CONTEXTSTREAM_UPGRADE_URL` | No | Upgrade link shown when Free users call PRO tools (default: `https://contextstream.io/pricing`) |

package/dist/index.js

@@ -6885,6 +6885,118 @@ W:${wsHint}
     if (params?.limit) query.set("limit", String(params.limit));
     return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/search?${query.toString()}`, { method: "GET" });
   }
+  /**
+   * Get knowledge extracted from GitHub (decisions, lessons, insights)
+   */
+  async githubKnowledge(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub knowledge");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.node_type) query.set("node_type", params.node_type);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/knowledge${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get knowledge extracted from Slack (decisions, lessons, insights)
+   */
+  async slackKnowledge(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack knowledge");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.node_type) query.set("node_type", params.node_type);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/knowledge${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get integration status for all providers in a workspace
+   */
+  async integrationsStatus(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for integrations status");
+    }
+    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
@@ -6894,6 +7006,7 @@ import * as path4 from "node:path";
 // src/rules-templates.ts
 var DEFAULT_CLAUDE_MCP_SERVER_NAME = "contextstream";
 var CONTEXTSTREAM_TOOL_NAMES = [
+  // Session/Context (core)
   "session_init",
   "context_smart",
   "session_summary",
@@ -6906,9 +7019,100 @@ var CONTEXTSTREAM_TOOL_NAMES = [
   "session_smart_search",
   "session_compress",
   "session_delta",
+  // Editor Rules
   "generate_editor_rules",
+  // Workspaces
   "workspace_associate",
-  "workspace_bootstrap"
+  "workspace_bootstrap",
+  "workspaces_list",
+  "workspaces_create",
+  "workspaces_update",
+  "workspaces_delete",
+  "workspaces_get",
+  "workspaces_overview",
+  "workspaces_analytics",
+  "workspaces_content",
+  // Projects
+  "projects_list",
+  "projects_create",
+  "projects_update",
+  "projects_delete",
+  "projects_get",
+  "projects_overview",
+  "projects_statistics",
+  "projects_files",
+  "projects_index",
+  "projects_index_status",
+  "projects_ingest_local",
+  // Search
+  "search_semantic",
+  "search_hybrid",
+  "search_keyword",
+  "search_pattern",
+  "search_suggestions",
+  // Memory
+  "memory_create_event",
+  "memory_bulk_ingest",
+  "memory_list_events",
+  "memory_create_node",
+  "memory_list_nodes",
+  "memory_search",
+  "memory_decisions",
+  "memory_get_event",
+  "memory_update_event",
+  "memory_delete_event",
+  "memory_distill_event",
+  "memory_get_node",
+  "memory_update_node",
+  "memory_delete_node",
+  "memory_supersede_node",
+  "memory_timeline",
+  "memory_summary",
+  // Graph
+  "graph_related",
+  "graph_path",
+  "graph_decisions",
+  "graph_dependencies",
+  "graph_call_path",
+  "graph_impact",
+  "graph_circular_dependencies",
+  "graph_unused_code",
+  "graph_contradictions",
+  // AI (PRO)
+  "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",
+  // Slack Integration (PRO)
+  "slack_stats",
+  "slack_channels",
+  "slack_contributors",
+  "slack_activity",
+  "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"
 ];
 function applyMcpToolPrefix(markdown, toolPrefix) {
   const toolPattern = CONTEXTSTREAM_TOOL_NAMES.join("|");
@@ -7069,6 +7273,55 @@ session_capture(event_type="decision", title="Auth Implementation Complete", con
 # Check past decisions
 session_recall(query="what did we decide about caching?")
 \`\`\`
+
+---
+
+### Full Tool Catalog
+
+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\`
+
+**Workspaces**:
+\`workspaces_list\`, \`workspaces_create\`, \`workspaces_update\`, \`workspaces_delete\`, \`workspaces_get\`, \`workspaces_overview\`, \`workspaces_analytics\`, \`workspaces_content\`
+
+**Projects**:
+\`projects_list\`, \`projects_create\`, \`projects_update\`, \`projects_delete\`, \`projects_get\`, \`projects_overview\`, \`projects_statistics\`, \`projects_files\`, \`projects_index\`, \`projects_index_status\`, \`projects_ingest_local\`
+
+**Search**:
+\`search_semantic\`, \`search_hybrid\`, \`search_keyword\`, \`search_pattern\`, \`search_suggestions\`
+
+**Memory**:
+\`memory_create_event\`, \`memory_bulk_ingest\`, \`memory_list_events\`, \`memory_create_node\`, \`memory_list_nodes\`, \`memory_search\`, \`memory_decisions\`, \`memory_get_event\`, \`memory_update_event\`, \`memory_delete_event\`, \`memory_distill_event\`, \`memory_get_node\`, \`memory_update_node\`, \`memory_delete_node\`, \`memory_supersede_node\`, \`memory_timeline\`, \`memory_summary\`
+
+**Graph** (code analysis):
+\`graph_related\`, \`graph_path\`, \`graph_decisions\`, \`graph_dependencies\`, \`graph_call_path\`, \`graph_impact\`, \`graph_circular_dependencies\`, \`graph_unused_code\`, \`graph_contradictions\`
+
+**AI** (PRO):
+\`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_knowledge\`, \`github_summary\`
+
+**Slack Integration** (PRO):
+\`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();
 var CONTEXTSTREAM_RULES_MINIMAL = `
 ## ContextStream (Minimal)
@@ -7080,6 +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(...)\`.
+
+### 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: {
@@ -9668,6 +9935,258 @@ Use this to find specific issues, PRs, or discussions.`,
       return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "github_knowledge",
+    {
+      title: "GitHub extracted knowledge",
+      description: `Get knowledge extracted from GitHub issues and PRs.
+Returns: decisions, lessons, and insights automatically distilled from GitHub conversations.
+This surfaces key decisions and learnings from your repository discussions.
+
+Example queries:
+- "What decisions were made about authentication?"
+- "What lessons learned from production incidents?"
+- "Show recent architectural decisions"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum items to return (default: 20)"),
+        node_type: external_exports.enum(["decision", "lesson", "fact", "insight"]).optional().describe("Filter by knowledge type")
+      })
+    },
+    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.githubKnowledge({ workspace_id: workspaceId, limit: input.limit, node_type: input.node_type });
+      if (result.length === 0) {
+        return { content: [{ type: "text", text: "No knowledge extracted from GitHub yet. Knowledge is distilled from issues/PRs after sync." }] };
+      }
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
+  );
+  registerTool(
+    "slack_knowledge",
+    {
+      title: "Slack extracted knowledge",
+      description: `Get knowledge extracted from Slack conversations.
+Returns: decisions, lessons, and insights automatically distilled from Slack discussions.
+This surfaces key decisions and learnings from your team conversations.
+
+Example queries:
+- "What decisions were made in #engineering this week?"
+- "Show lessons learned from outages"
+- "What architectural insights came from Slack?"`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum items to return (default: 20)"),
+        node_type: external_exports.enum(["decision", "lesson", "fact", "insight"]).optional().describe("Filter by knowledge type")
+      })
+    },
+    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.slackKnowledge({ workspace_id: workspaceId, limit: input.limit, node_type: input.node_type });
+      if (result.length === 0) {
+        return { content: [{ type: "text", text: "No knowledge extracted from Slack yet. Knowledge is distilled from high-engagement threads after sync." }] };
+      }
+      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",
+    {
+      title: "Integration health status",
+      description: `Check the status of all integrations (GitHub, Slack, etc.) for a workspace.
+Returns: connection status, last sync time, next sync time, and any errors.
+Use this to verify integrations are healthy and syncing properly.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional()
+      })
+    },
+    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.integrationsStatus({ workspace_id: workspaceId });
+      if (result.length === 0) {
+        return { content: [{ type: "text", text: "No integrations configured for this workspace." }] };
+      }
+      const formatted = result.map((i) => {
+        const status = i.status === "connected" ? "\u2705" : i.status === "error" ? "\u274C" : "\u23F3";
+        const lastSync = i.last_sync_at ? new Date(i.last_sync_at).toLocaleString() : "Never";
+        const error = i.error_message ? ` (Error: ${i.error_message})` : "";
+        return `${status} ${i.provider}: ${i.status} | Last sync: ${lastSync} | Resources: ${i.resources_synced}${error}`;
+      }).join("\n");
+      return { content: [{ type: "text", text: formatted }], structuredContent: toStructured(result) };
+    }
+  );
 }
 
 // src/resources.ts
@@ -10256,6 +10775,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
@@ -10266,7 +10787,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";
@@ -10535,6 +11056,17 @@ Created API key: ${maskApiKey(apiKey)}
     console.log("  2) Extended \u2014 more guidance + examples (higher token overhead)");
     const modeChoice = normalizeInput(await rl.question("Choose [1/2] (default 1): ")) || "1";
     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"];
     console.log('\nSelect editors to configure (comma-separated numbers, or "all"):');
     editors.forEach((e, i) => console.log(`  ${i + 1}) ${EDITOR_LABELS[e]}`));
@@ -10565,9 +11097,9 @@ Created API key: ${maskApiKey(apiKey)}
     const mcpChoiceDefault = hasCodex && !hasProjectMcpEditors ? "1" : "3";
     const mcpChoice = normalizeInput(await rl.question(`Choose [${hasCodex && !hasProjectMcpEditors ? "1/2" : "1/2/3/4"}] (default ${mcpChoiceDefault}): `)) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey });
-    const mcpServerClaude = buildContextStreamMcpServer({ apiUrl, apiKey, toolset: "core" });
-    const vsCodeServer = buildContextStreamVsCodeServer({ apiUrl, apiKey });
+    const mcpServer = toolset === "full" ? buildContextStreamMcpServer({ apiUrl, apiKey, toolset: "full" }) : buildContextStreamMcpServer({ apiUrl, apiKey });
+    const mcpServerClaude = buildContextStreamMcpServer({ apiUrl, apiKey, toolset });
+    const vsCodeServer = toolset === "full" ? buildContextStreamVsCodeServer({ apiUrl, apiKey, toolset: "full" }) : buildContextStreamVsCodeServer({ apiUrl, apiKey });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
       console.log("\nInstalling global MCP config...");
@@ -10581,7 +11113,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;
@@ -10614,7 +11147,7 @@ Created API key: ${maskApiKey(apiKey)}
               }
             }
             console.log("- Claude Code: global MCP config is best done via `claude mcp add --transport stdio ...` (see docs).");
-            console.log("  macOS/Linux: claude mcp add --transport stdio contextstream --scope user --env CONTEXTSTREAM_API_URL=... --env CONTEXTSTREAM_API_KEY=... --env CONTEXTSTREAM_TOOLSET=core -- npx -y @contextstream/mcp-server");
+            console.log(`  macOS/Linux: claude mcp add --transport stdio contextstream --scope user --env CONTEXTSTREAM_API_URL=... --env CONTEXTSTREAM_API_KEY=... --env CONTEXTSTREAM_TOOLSET=${toolset} -- npx -y @contextstream/mcp-server`);
             console.log("  Windows (native): use `cmd /c npx -y @contextstream/mcp-server` after `--` if `npx` is not found.");
             continue;
           }
@@ -10817,10 +11350,15 @@ Applying to ${projects.length} project(s)...`);
       const skipped = writeActions.filter((a) => a.status === "skipped").length;
       const dry = writeActions.filter((a) => a.status === "dry-run").length;
       console.log(`Summary: ${created} created, ${updated} updated, ${appended} appended, ${skipped} skipped, ${dry} dry-run.`);
+      console.log(`Toolset: ${toolset} (${toolset === "full" ? "~86 tools" : "~17 core tools"})`);
     }
     console.log("\nNext steps:");
     console.log("- Restart your editor/CLI after changing MCP config or rules.");
+    console.log("- Prefer ContextStream search first: use session_smart_search (or mcp__contextstream__session_smart_search) before raw repo scans (rg/ls/find).");
     console.log("- If any tools require UI-based MCP setup (e.g. Cline/Kilo/Roo global), follow https://contextstream.io/docs/mcp.");
+    if (toolset === "full") {
+      console.log("- Note: Claude Code/Desktop may warn about large tool contexts. This is expected with the full toolset.");
+    }
   } finally {
     rl.close();
   }

package/package.json

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