@notebook-intelligence/notebook-intelligence 2.4.2 → 2.6.0

package/README.md

@@ -94,18 +94,18 @@ jupyter lab --NotebookIntelligence.notebook_execute_tool=env_enabled
 
 ### Configuration files
 
-NBI saves configuration at `~/.jupyter/nbi-config.json`. It also supports environment wide base configuration at `<env-prefix>/share/jupyter/nbi-config.json`. Organizations can ship default configuration at this environment wide config path. User's changes will be stored as overrides at `~/.jupyter/nbi-config.json`.
+NBI saves configuration at `~/.jupyter/nbi/config.json`. It also supports environment wide base configuration at `<env-prefix>/share/jupyter/nbi/config.json`. Organizations can ship default configuration at this environment wide config path. User's changes will be stored as overrides at `~/.jupyter/nbi/config.json`.
 
 These config files are used for saving LLM provider, model and MCP configuration. Note that API keys you enter for your custom LLM providers will also be stored in these config files.
 
 > [!IMPORTANT]
-> Note that updating nbi-config.json manually requires restarting JupyterLab to take effect.
+> Note that updating config.json manually requires restarting JupyterLab to take effect.
 
 ### Model Context Protocol ([MCP](https://modelcontextprotocol.io)) Support
 
 NBI seamlessly integrates with MCP servers. It supports servers with both Standard Input/Output (stdio) and Server-Sent Events (SSE) transports. The MCP support is limited to server tools at the moment.
 
-You can easily add MCP servers to NBI by editing the configuration file [nbi-config.json](#configuration-files). Simply add a key "mcp" and "mcpServers" under it as shown below.
+You can easily add MCP servers to NBI by editing the configuration file [~/.jupyter/nbi/mcp.json](#configuration-files). Environment wide base configuration is also support using the file at `<env-prefix>/share/jupyter/nbi/mcp.json`.
 
 > [!NOTE]
 > Using MCP servers requires an LLM model with tool calling capabilities. All of the GitHub Copilot models provided in NBI support this feature. If you are using other providers make sure you choose a tool calling capable model.
@@ -113,47 +113,24 @@ You can easily add MCP servers to NBI by editing the configuration file [nbi-con
 > [!CAUTION]
 > Note that most MCP servers are run on the same computer as your JupyterLab installation and they can make irreversible changes to your computer and/or access private data. Make sure that you only install MCP servers from trusted sources.
 
+### MCP Config file example
+
 ```json
 {
-    "chat_model": {
-        ...
-    },
-    ...<other configuration>,
-
-    "mcp": {
-        "mcpServers": {
-            "filesystem": {
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/Users/mbektas/mcp-test"
-                ]
-            },
-        }
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-filesystem",
+        "/Users/mbektas/mcp-test"
+      ]
     }
+  }
 }
 ```
 
-This will automatically create a new chat participant in NBI and you can access it by starting your prompts with `@mcp`. Use `@mcp /info` prompt to get information on the tools provided by the MCP servers you configured. This chat participant will have access all the tools provided by the servers you configure.
-
-<img src="media/mcp-prompt.png" alt="Settings dialog" width=600 />
-
-By default, each tool call to MCP servers will require approval. If you would like to auto approve tools, you can do so by using the `"alwaysAllow": []` configuration key in the nbi-config.json. Simply list the names of tools.
-
-```json
-"mcpServers": {
-    "filesystem": {
-        "command": "npx",
-        "args": [
-            "-y",
-            "@modelcontextprotocol/server-filesystem",
-            "/Users/mbektas/mcp-test"
-        ],
-        "alwaysAllow": ["list_allowed_directories", "list_directory"]
-    },
-}
-```
+You can use Agent mode to access tools provided by MCP servers you configured.
 
 For servers with stdio transport, you can also set additional environment variables by using the `env` key. Environment variables are specified as key value pairs.
 
@@ -169,12 +146,12 @@ For servers with stdio transport, you can also set additional environment variab
 }
 ```
 
-Below is an example of a server configuration with SSE transport. For SSE transport servers, you can also specify headers to be sent as part of the requests.
+Below is an example of a server configuration with Streamable HTTP transport. For Streamable HTTP transport servers, you can also specify headers to be sent as part of the requests.
 
 ```json
 "mcpServers": {
     "remoterservername": {
-        "url": "http://127.0.0.1:8080/sse",
+        "url": "http://127.0.0.1:8080/mcp",
         "headers": {
             "Authorization": "Bearer mysecrettoken"
         }
@@ -198,77 +175,119 @@ If you have multiple servers configured but you would like to disable some for a
 }
 ```
 
-#### Grouping MCP servers
+### Ruleset System
 
-When you integrate multiple MCP servers to NBI, all of their tools will be available under the same chat participant `@mcp`. However, this may not be ideal in many situations. You may want to group certain servers and their tools based on their functionality. NBI lets you do that easily by configuring MCP chat participants. You can list the servers for each custom participant. If there are any unassigned MCP servers, then they will be used the default `@mcp` chat participant.
+NBI includes a powerful ruleset system that allows you to define custom guidelines and best practices that are automatically injected into AI prompts. This helps ensure consistent coding standards, project-specific conventions, and domain knowledge across all AI interactions.
 
-Below is an example of creating a custom MCP participant. This configuration results in two chat participants `@mcp-fs` with `filesytem` MC server tools and `@mcp` with `servername1` and `servername1` MCP server tools.
+#### How It Works
 
-```json
-{
-    "chat_model": {
-        ...
-    },
-    ...<other configuration>,
-
-    "mcp": {
-        "mcpServers": {
-            "filesystem": {
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/Users/mbektas/mcp-test"
-                ]
-            },
-            "servername1": {
-                "command": "",
-                "args": [],
-            },
-            "servername2": {
-                "command": "",
-                "args": [],
-                "disabled": true
-            }
-        },
-        "participants": {
-            "fs": {
-                "name": "MCP - File system",
-                "servers": ["filesystem"]
-            }
-        }
-    }
-}
+Rules are markdown files with optional YAML frontmatter stored in `~/.jupyter/nbi/rules/`. They are automatically discovered and applied based on context (file type, notebook kernel, chat mode).
+
+#### Creating Rules
+
+**Global Rules** - Apply to all contexts:
+
+Create a file like `~/.jupyter/nbi/rules/01-coding-standards.md`:
+
+```markdown
+---
+priority: 10
+---
+
+# Coding Standards
+
+- Always use type hints in Python functions
+- Prefer list comprehensions over loops when appropriate
+- Add docstrings to all public functions
 ```
 
-#### Using NBI tools within MCP chat participants
+**Mode-Specific Rules** - Apply only to specific chat modes:
 
-NBI allows you to access built-in tools from an MCP participant. You can do that by adding the list of built in NBI tools to your MCP participant configuration. The built-in tools available to MCP are `create_new_notebook`, `add_markdown_cell_to_notebook`, `add_code_cell_to_notebook`. Below is an example that integrates all these tools to MCP participant `@mcp-fs`.
+NBI supports mode-specific rules for three modes:
+
+- **ask** - Question/answer mode
+- **agent** - Autonomous agent mode with tool access
+- **inline-chat** - Inline code generation and editing
+
+Create a file like `~/.jupyter/nbi/rules/modes/agent/01-testing.md`:
+
+```markdown
+---
+priority: 20
+scope:
+  kernels: ['python3']
+---
+
+# Testing Guidelines
+
+When writing code in agent mode:
+
+- Always include error handling
+- Add logging for debugging
+- Test edge cases
+```
+
+#### Rule Frontmatter Options
+
+```yaml
+---
+apply: always # 'always', 'auto', or 'manual'
+active: true # Enable/disable the rule
+priority: 10 # Lower numbers = higher priority
+scope:
+  file_patterns: # Apply to specific file patterns
+    - '*.py'
+    - 'test_*.ipynb'
+  kernels: # Apply to specific notebook kernels
+    - 'python3'
+    - 'ir'
+  directories: # Apply to specific directories
+    - '/projects/ml'
+---
+```
+
+#### Configuration
+
+**Enable/Disable Rules System:**
+
+Edit `~/.jupyter/nbi/config.json`:
 
 ```json
-"participants": {
-    "fs": {
-        "name": "MCP - File system",
-        "servers": ["filesystem"],
-        "nbiTools": [
-            "create_new_notebook",
-            "add_markdown_cell_to_notebook",
-            "add_code_cell_to_notebook"
-        ]
-    }
+{
+  "rules_enabled": true
 }
 ```
 
-This chat participant will allow you to run example prompts like below.
+**Auto-Reload Configuration:**
 
-```
-@mcp-fs list the directories I have access to.
-```
+Rules are automatically reloaded when changed (enabled by default). This behavior is controlled by the `NBI_RULES_AUTO_RELOAD` environment variable.
 
+To disable auto-reload:
+
+```bash
+export NBI_RULES_AUTO_RELOAD=false
+jupyter lab
 ```
-@mcp-fs add a code cell which demonstrates ipywidgets Button to this notebook.
+
+Or to enable (default):
+
+```bash
+export NBI_RULES_AUTO_RELOAD=true
+jupyter lab
 ```
 
+#### Managing Rules
+
+Rules are automatically discovered from:
+
+- **Global rules**: `~/.jupyter/nbi/rules/*.md`
+- **Mode-specific rules**: `~/.jupyter/nbi/rules/modes/{mode}/*.md` where `{mode}` can be:
+  - `ask` - For question/answer interactions
+  - `agent` - For autonomous agent operations
+  - `inline-chat` - For inline code generation
+
+Rules are applied in priority order (lower numbers first) and can be toggled on/off without deleting the files.
+
 ### Developer documentation
 
 For building locally and contributing see the [developer documentatation](CONTRIBUTING.md).

package/lib/api.d.ts

@@ -22,6 +22,10 @@ export declare class NBIConfig {
     get usingGitHubCopilotModel(): boolean;
     get storeGitHubAccessToken(): boolean;
     get toolConfig(): any;
+    get mcpServers(): any;
+    getMCPServer(serverId: string): any;
+    getMCPServerPrompt(serverId: string, promptName: string): any;
+    get mcpServerSettings(): any;
     capabilities: any;
     chatParticipants: IChatParticipant[];
     changed: Signal<this, void>;
@@ -38,16 +42,19 @@ export declare class NBIAPI {
     static initializeWebsocket(): Promise<void>;
     static getLoginStatus(): GitHubCopilotLoginStatus;
     static getDeviceVerificationInfo(): IDeviceVerificationInfo;
+    static getGHLoginRequired(): boolean;
+    static getChatEnabled(): any;
+    static getInlineCompletionEnabled(): any;
     static loginToGitHub(): Promise<unknown>;
     static logoutFromGitHub(): Promise<unknown>;
     static updateGitHubLoginStatus(): Promise<void>;
     static fetchCapabilities(): Promise<void>;
     static setConfig(config: any): Promise<void>;
     static updateOllamaModelList(): Promise<void>;
-    static reloadMCPServerList(): Promise<any>;
     static getMCPConfigFile(): Promise<any>;
     static setMCPConfigFile(config: any): Promise<any>;
     static chatRequest(messageId: string, chatId: string, prompt: string, language: string, filename: string, additionalContext: IContextItem[], chatMode: string, toolSelections: IToolSelections, responseEmitter: IChatCompletionResponseEmitter): Promise<void>;
+    static reloadMCPServers(): Promise<any>;
     static generateCode(chatId: string, prompt: string, prefix: string, suffix: string, existingCode: string, language: string, filename: string, responseEmitter: IChatCompletionResponseEmitter): Promise<void>;
     static sendChatUserInput(messageId: string, data: any): Promise<void>;
     static sendWebSocketMessage(messageId: string, messageType: RequestDataType, data: any): Promise<void>;

package/lib/api.js

@@ -53,6 +53,22 @@ export class NBIConfig {
     get toolConfig() {
         return this.capabilities.tool_config;
     }
+    get mcpServers() {
+        return this.toolConfig.mcpServers;
+    }
+    getMCPServer(serverId) {
+        return this.toolConfig.mcpServers.find((server) => server.id === serverId);
+    }
+    getMCPServerPrompt(serverId, promptName) {
+        const server = this.getMCPServer(serverId);
+        if (server) {
+            return server.prompts.find((prompt) => prompt.name === promptName);
+        }
+        return null;
+    }
+    get mcpServerSettings() {
+        return this.capabilities.mcp_server_settings;
+    }
 }
 class NBIAPI {
     static async initialize() {
@@ -61,7 +77,10 @@ class NBIAPI {
         NBIAPI.initializeWebsocket();
         this._messageReceived.connect((_, msg) => {
             msg = JSON.parse(msg);
-            if (msg.type === BackendMessageType.GitHubCopilotLoginStatusChange) {
+            if (msg.type === BackendMessageType.MCPServerStatusChange) {
+                this.fetchCapabilities();
+            }
+            else if (msg.type === BackendMessageType.GitHubCopilotLoginStatusChange) {
                 this.updateGitHubLoginStatus().then(() => {
                     this.githubLoginStatusChanged.emit();
                 });
@@ -92,6 +111,21 @@ class NBIAPI {
     static getDeviceVerificationInfo() {
         return this._deviceVerificationInfo;
     }
+    static getGHLoginRequired() {
+        return (this.config.usingGitHubCopilotModel &&
+            NBIAPI.getLoginStatus() === GitHubCopilotLoginStatus.NotLoggedIn);
+    }
+    static getChatEnabled() {
+        return this.config.chatModel.provider === GITHUB_COPILOT_PROVIDER_ID
+            ? !this.getGHLoginRequired()
+            : this.config.llmProviders.find(provider => provider.id === this.config.chatModel.provider);
+    }
+    static getInlineCompletionEnabled() {
+        return this.config.inlineCompletionModel.provider ===
+            GITHUB_COPILOT_PROVIDER_ID
+            ? !this.getGHLoginRequired()
+            : this.config.llmProviders.find(provider => provider.id === this.config.inlineCompletionModel.provider);
+    }
     static async loginToGitHub() {
         this._loginStatus = GitHubCopilotLoginStatus.ActivatingDevice;
         return new Promise((resolve, reject) => {
@@ -144,9 +178,19 @@ class NBIAPI {
         return new Promise((resolve, reject) => {
             requestAPI('capabilities', { method: 'GET' })
                 .then(data => {
+                const oldConfig = {
+                    capabilities: structuredClone(this.config.capabilities),
+                    chatParticipants: structuredClone(this.config.chatParticipants)
+                };
                 this.config.capabilities = structuredClone(data);
                 this.config.chatParticipants = structuredClone(data.chat_participants);
-                this.configChanged.emit();
+                const newConfig = {
+                    capabilities: structuredClone(this.config.capabilities),
+                    chatParticipants: structuredClone(this.config.chatParticipants)
+                };
+                if (JSON.stringify(newConfig) !== JSON.stringify(oldConfig)) {
+                    this.configChanged.emit();
+                }
                 resolve();
             })
                 .catch(reason => {
@@ -183,19 +227,6 @@ class NBIAPI {
             });
         });
     }
-    static async reloadMCPServerList() {
-        return new Promise((resolve, reject) => {
-            requestAPI('reload-mcp-servers', { method: 'POST' })
-                .then(async (data) => {
-                await NBIAPI.fetchCapabilities();
-                resolve(data);
-            })
-                .catch(reason => {
-                console.error(`Failed to reload MCP server list.\n${reason}`);
-                reject(reason);
-            });
-        });
-    }
     static async getMCPConfigFile() {
         return new Promise((resolve, reject) => {
             requestAPI('mcp-config-file', { method: 'GET' })
@@ -244,6 +275,19 @@ class NBIAPI {
             }
         }));
     }
+    static async reloadMCPServers() {
+        return new Promise((resolve, reject) => {
+            requestAPI('reload-mcp-servers', { method: 'POST' })
+                .then(async (data) => {
+                await NBIAPI.fetchCapabilities();
+                resolve(data);
+            })
+                .catch(reason => {
+                console.error(`Failed to reload MCP servers.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
     static async generateCode(chatId, prompt, prefix, suffix, existingCode, language, filename, responseEmitter) {
         const messageId = UUID.uuid4();
         this._messageReceived.connect((_, msg) => {

package/lib/chat-sidebar.d.ts

@@ -42,6 +42,8 @@ export interface IInlinePromptWidgetOptions {
     existingCode: string;
     prefix: string;
     suffix: string;
+    language?: string;
+    filename?: string;
     onRequestSubmitted: (prompt: string) => void;
     onRequestCancelled: () => void;
     onContentStream: (content: string) => void;
@@ -73,12 +75,12 @@ export declare class GitHubCopilotLoginDialogBody extends ReactWidget {
     render(): JSX.Element;
     private _onLoggedIn;
 }
-export declare class ConfigurationDialogBody extends ReactWidget {
+export declare class FormInputDialogBody extends ReactWidget {
     constructor(options: {
-        onSave: () => void;
-        onEditMCPConfigClicked: () => void;
+        fields: any;
+        onDone: (formData: any) => void;
     });
     render(): JSX.Element;
-    private _onEditMCPConfigClicked;
-    private _onSave;
+    private _fields;
+    private _onDone;
 }