{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-jupyter-ai","slug":"jupyter-ai","name":"Jupyter AI","type":"repo","url":"https://github.com/jupyterlab/jupyter-ai","page_url":"https://unfragile.ai/jupyter-ai","categories":["frameworks-sdks"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-jupyter-ai__cap_0","uri":"capability://tool.use.integration.multi.provider.llm.abstraction.via.litellm","name":"multi-provider llm abstraction via litellm","description":"Provides unified vendor-agnostic access to 1000+ language models across 100+ providers (OpenAI, Anthropic, Ollama, GPT4All, etc.) through a single LiteLLM abstraction layer. Jupyter AI v3 migrated from LangChain to LiteLLM, reducing startup time from 10s to 2.5s by eliminating heavy optional dependencies. The architecture uses a provider registry pattern where each model provider is registered with standardized request/response handling, enabling seamless model switching without code changes.","intents":["Switch between local and cloud LLM providers without rewriting prompts or integration code","Use open-source models (Ollama, GPT4All) alongside commercial APIs in the same notebook","Reduce startup latency and memory footprint by avoiding monolithic dependency chains","Support 1000+ models out-of-box without manual configuration per model"],"best_for":["Data scientists experimenting with multiple LLM providers in notebooks","Teams wanting to avoid vendor lock-in while maintaining flexibility","Researchers comparing model outputs across providers without infrastructure changes"],"limitations":["LiteLLM abstraction adds ~50-100ms per request for provider routing and normalization","Custom provider-specific parameters may require direct LiteLLM config; not all advanced features exposed through Jupyter AI UI","Rate limiting and quota management delegated to underlying provider SDKs — no built-in cross-provider rate limiter"],"requires":["Python 3.9+","API keys for cloud providers (OpenAI, Anthropic, etc.) OR local Ollama/GPT4All installation","JupyterLab 4.0+ or Jupyter Notebook 7.5+"],"input_types":["text prompts","model identifiers (e.g., 'gpt-4', 'claude-3-sonnet', 'ollama/llama2')","provider configuration (API keys, endpoints)"],"output_types":["text completions","streaming token chunks","structured metadata (token counts, model info)"],"categories":["tool-use-integration","model-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_1","uri":"capability://text.generation.language.conversational.chat.interface.with.multi.chat.support.and.rtc.persistence","name":"conversational chat interface with multi-chat support and rtc persistence","description":"Provides a native JupyterLab chat UI built on the jupyterlab-chat framework with support for multiple concurrent chat sessions, real-time collaboration (RTC), and persistent storage as .chat files. Each chat maintains independent conversation history and can be saved/loaded independently. The architecture delegates UI rendering and state management to jupyterlab-chat while Jupyter AI handles AI persona selection, message routing, and LLM invocation. Chats are persisted as structured files enabling version control and sharing.","intents":["Have multiple independent AI conversations in parallel within the same notebook session","Persist chat history across notebook restarts and share conversations with collaborators","Collaborate on the same chat in real-time with other notebook users (RTC)","Switch between different AI personas (@jupyternaut, custom) within a single chat"],"best_for":["Teams collaborating on data analysis with persistent audit trails","Educators sharing example conversations with students","Researchers documenting exploratory analysis with AI assistance"],"limitations":["RTC collaboration requires JupyterHub or shared Jupyter server; not available in local single-user notebooks","Chat files (.chat format) are proprietary to Jupyter AI; no standardized export to markdown/JSON without custom tooling","Chat history not automatically synced across multiple notebook tabs — each tab maintains separate session state"],"requires":["JupyterLab 4.0+ or Jupyter Notebook 7.5+","jupyterlab-chat framework (bundled with Jupyter AI)","JupyterHub for RTC collaboration features"],"input_types":["text messages","file attachments via @file: context commands","code selections from notebook cells"],"output_types":["text responses","streaming token chunks",".chat file persistence","structured message metadata (timestamps, persona, token counts)"],"categories":["text-generation-language","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_10","uri":"capability://memory.knowledge.persistent.chat.storage.with.chat.file.format.and.version.control.compatibility","name":"persistent chat storage with .chat file format and version control compatibility","description":"Saves chat conversations to .chat files (structured text format) that can be committed to version control, shared, and reopened in future sessions. The file format includes message history, metadata (timestamps, personas, model info), and RTC state. Files are stored in the notebook directory and can be manually edited or processed by external tools. The architecture uses a file-based persistence layer that serializes/deserializes chat state without requiring a database.","intents":["Preserve chat history across notebook restarts and sessions","Share AI-assisted analysis conversations with collaborators","Version control AI conversations alongside code and data","Audit AI interactions for compliance or learning purposes"],"best_for":["Teams collaborating on data analysis with audit requirements","Educators documenting AI-assisted learning","Researchers preserving exploratory analysis workflows"],"limitations":[".chat format is proprietary to Jupyter AI; no standard export to markdown/JSON without custom tooling","Large chat histories (1000+ messages) may cause file I/O slowdowns","Chat files stored in notebook directory; no centralized chat storage or search","No built-in chat deduplication or compression; file size grows linearly with message count"],"requires":["JupyterLab 4.0+ or Jupyter Notebook 7.5+","Write access to notebook directory"],"input_types":["chat messages and metadata","RTC state (for collaboration)"],"output_types":[".chat files (structured text format)","chat history for reopening","metadata for audit/analysis"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_11","uri":"capability://tool.use.integration.entry.points.api.for.third.party.extension.development","name":"entry points api for third-party extension development","description":"Provides a setuptools entry_points-based plugin system allowing third-party packages to extend Jupyter AI with custom personas, slash commands, and model providers without modifying core code. Extensions register handlers via entry_points in their setup.py/pyproject.toml, and Jupyter AI discovers and loads them at startup. The architecture uses a registry pattern where each extension type (persona, command, provider) has a well-defined interface that extensions must implement.","intents":["Build custom AI personas for domain-specific tasks without forking Jupyter AI","Create specialized slash commands for team workflows","Add support for proprietary or custom LLM providers","Distribute extensions via PyPI for community reuse"],"best_for":["Extension developers building specialized AI assistants","Organizations with custom LLM providers or models","Teams standardizing on custom personas and commands"],"limitations":["Entry_points discovery happens at startup; no hot-reload for new extensions","Extension interface changes require version bumps; no backward compatibility guarantees","No built-in extension marketplace or discovery mechanism","Debugging extension loading failures requires understanding setuptools entry_points"],"requires":["Python 3.9+","setuptools knowledge","Understanding of Jupyter AI extension interfaces"],"input_types":["extension class definitions (Persona, Command, Provider subclasses)","entry_points configuration in setup.py/pyproject.toml"],"output_types":["registered extensions in Jupyter AI registry","extension handlers invoked by core system"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_12","uri":"capability://tool.use.integration.local.model.support.via.ollama.and.gpt4all.integration","name":"local model support via ollama and gpt4all integration","description":"Provides native integration with local LLM runners (Ollama, GPT4All) through LiteLLM's provider support, enabling users to run models locally without cloud API calls. Models are specified by provider prefix (e.g., 'ollama/llama2', 'gpt4all/orca-mini') and Jupyter AI routes requests to the appropriate local endpoint. The architecture treats local models identically to cloud models through the LiteLLM abstraction, enabling seamless switching between local and cloud providers.","intents":["Run LLMs locally for privacy-sensitive work without sending data to cloud providers","Reduce latency and costs by using local models for development/testing","Experiment with open-source models (Llama, Mistral, Orca) without API keys","Build offline-capable notebooks that work without internet connectivity"],"best_for":["Organizations with data privacy requirements","Developers optimizing for latency and cost","Researchers experimenting with open-source models","Teams in offline or low-bandwidth environments"],"limitations":["Local model performance depends on hardware; CPU-only inference is slow (10-50 tokens/sec vs 100+ for cloud)","Model downloads are large (2-50GB); requires significant disk space","Ollama/GPT4All must be running separately; Jupyter AI doesn't manage lifecycle","Local models typically lower quality than commercial models (GPT-4, Claude); may require prompt engineering"],"requires":["Ollama or GPT4All installed and running locally","Sufficient disk space for model downloads (2-50GB per model)","GPU recommended for reasonable performance (CPU inference is slow)"],"input_types":["model identifiers (e.g., 'ollama/llama2', 'gpt4all/orca-mini')","local endpoint URLs (if using custom Ollama/GPT4All instances)"],"output_types":["local model completions","streaming tokens from local models","identical output format to cloud models"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_2","uri":"capability://code.generation.editing.ipython.magic.commands.ai.and.ai.for.programmatic.ai.access","name":"ipython magic commands (%ai and %%ai) for programmatic ai access","description":"Provides line and cell magic commands (%ai for single-line, %%ai for multi-line blocks) that invoke LLMs directly from notebook code without opening the chat UI. These magics support variable interpolation (accessing notebook variables in prompts), output format control (returning raw text, structured data, or code), and reproducible execution. The magic system integrates with IPython's kernel extension architecture, making it available in any IPython environment (local notebooks, remote kernels, JupyterHub).","intents":["Generate code or text programmatically within notebook cells without switching to chat UI","Interpolate notebook variables into prompts for dynamic, data-driven AI requests","Capture AI outputs as variables for downstream processing or analysis","Create reproducible, version-controllable AI-assisted workflows"],"best_for":["Data scientists building reproducible analysis pipelines with AI assistance","Developers automating code generation as part of notebook workflows","Teams using notebooks as executable documentation with AI-generated content"],"limitations":["Magic commands execute synchronously — long-running LLM calls block cell execution; no built-in async/streaming support","Output format control limited to text, code, or raw; no structured JSON schema validation for generated outputs","Variable interpolation uses simple string substitution — no type coercion or escaping for complex objects"],"requires":["IPython kernel (any version compatible with Jupyter AI)","Jupyter AI extension installed and configured","Model provider API key or local model endpoint configured"],"input_types":["text prompts with variable interpolation (e.g., 'Analyze this data: {df}')","multi-line code blocks (%%ai magic)","notebook variables (accessible via Python variable names)"],"output_types":["text strings","code snippets","raw LLM responses","Python variables (assigned via magic output)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_3","uri":"capability://planning.reasoning.ai.personas.system.with.mention.routing.and.custom.persona.registration","name":"ai personas system with @-mention routing and custom persona registration","description":"Implements a multi-assistant framework where different AI personas (e.g., @jupyternaut, custom personas) can be selected per chat or message via @-mention syntax. Each persona is a registered handler that can have custom system prompts, model preferences, and behavior. The architecture uses an entry points API (setuptools entry_points) allowing third-party extensions to register custom personas without modifying core code. Messages are routed to the selected persona's handler, which constructs the final prompt and invokes the LLM.","intents":["Switch between specialized AI assistants (e.g., code expert, data analyst, documentation writer) within a single chat","Register custom personas with domain-specific prompts and model preferences","Build third-party extensions that provide new AI personas without forking Jupyter AI","Route messages to different models/providers based on persona selection"],"best_for":["Teams with domain-specific AI needs (e.g., ML engineers, data scientists, DevOps)","Extension developers building specialized AI assistants on top of Jupyter AI","Organizations wanting to enforce consistent system prompts across personas"],"limitations":["Persona selection is per-message; no session-level persona locking — users must @-mention each message","Custom personas require Python code and setuptools entry_points registration; no UI-based persona builder","No built-in persona versioning or A/B testing framework — all personas active simultaneously"],"requires":["Jupyter AI v3+","Python 3.9+ for custom persona development","setuptools entry_points knowledge for third-party persona registration"],"input_types":["text messages with @-mention syntax (e.g., '@jupyternaut explain this code')","persona configuration (system prompt, model ID, parameters)","custom persona Python classes (for extensions)"],"output_types":["text responses from selected persona","persona metadata (name, description, model info)","routed messages to persona handlers"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_4","uri":"capability://memory.knowledge.context.attachment.via.file.and.selection.commands","name":"context attachment via @file and @selection commands","description":"Provides slash-command syntax (@file:path/to/file, @selection) to attach notebook cells, file contents, or code selections as context to prompts. The system reads file contents or cell outputs at prompt time and injects them into the LLM context window. This enables AI to reason over actual code/data without manual copy-paste. The architecture uses a context resolver that normalizes different input types (files, cells, selections) into a unified context format before sending to the LLM.","intents":["Ask AI to analyze or refactor specific code files without copying them into the chat","Include notebook cell outputs or variables in prompts for data-driven AI requests","Build AI-assisted code review workflows by attaching files for analysis","Reference multiple files in a single prompt for cross-file reasoning"],"best_for":["Code review and refactoring workflows","Data analysis with AI assistance over actual datasets","Multi-file project understanding and documentation generation"],"limitations":["File size limits depend on LLM context window; large files may be truncated without warning","No automatic file diff generation — full file contents always included, not just changes","@file paths are relative to notebook directory; no support for absolute paths or symlinks","Context injection happens at prompt time — no caching or deduplication across multiple messages"],"requires":["JupyterLab 4.0+ or Jupyter Notebook 7.5+","Files must be accessible from notebook working directory","Chat UI (not available in magic commands)"],"input_types":["file paths (relative to notebook directory)","cell selections (notebook cell references)","code selections (highlighted text in editor)"],"output_types":["file contents injected into prompt","cell outputs/variables as context","AI responses analyzing attached context"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_5","uri":"capability://text.generation.language.slash.commands.for.specialized.ai.tasks.learn.fix.generate.export","name":"slash commands for specialized ai tasks (/learn, /fix, /generate, /export)","description":"Provides domain-specific slash commands that invoke pre-configured prompts and workflows for common tasks: /learn (explain concepts), /fix (debug code), /generate (create code), /export (format outputs). Each slash command is a registered handler that constructs a specialized system prompt and invokes the LLM with appropriate context. The architecture uses a command registry pattern similar to personas, allowing extensibility via entry_points. Commands can be chained or composed for multi-step workflows.","intents":["Quickly explain concepts or code without writing custom prompts","Debug errors with AI assistance using /fix command","Generate boilerplate or new code with /generate","Export AI responses in specific formats (markdown, code, etc.) with /export"],"best_for":["Developers seeking quick, focused AI assistance for common tasks","Teams standardizing on consistent prompts for code review and generation","Educators using Jupyter AI for teaching with guided AI interactions"],"limitations":["Slash commands are chat-UI only; not available in magic commands","Command output formats are fixed per command; limited customization without code changes","No command chaining or composition UI — commands execute independently","Command discovery requires documentation or trial; no built-in help system"],"requires":["JupyterLab 4.0+ or Jupyter Notebook 7.5+","Chat UI enabled","Model provider configured"],"input_types":["slash command syntax (e.g., '/fix' followed by error message)","selected code or context from notebook","command parameters (if supported)"],"output_types":["formatted explanations (/learn)","debugging suggestions (/fix)","generated code (/generate)","exported responses in specified format (/export)"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_6","uri":"capability://code.generation.editing.inline.code.completion.with.streaming.and.context.awareness","name":"inline code completion with streaming and context awareness","description":"Provides context-aware code completion suggestions that appear inline in the notebook editor as users type, with streaming token-by-token display. The completion engine analyzes the current cell context (imports, variable definitions, function signatures) and sends a completion request to the LLM with surrounding code as context. Results stream back and are rendered as ghost text suggestions that users can accept or dismiss. The architecture uses JupyterLab's completion provider API for integration.","intents":["Get real-time code suggestions as you type without breaking flow","Complete function calls with correct signatures based on imported modules","Generate boilerplate code (imports, class definitions) from context","Reduce typing for repetitive patterns"],"best_for":["Developers writing exploratory code in notebooks","Teams using Jupyter for rapid prototyping","Learners discovering Python APIs and patterns"],"limitations":["Completion latency depends on LLM response time; typically 500ms-2s for first token, may feel sluggish vs local completers","Context window limited to current cell + surrounding cells; no cross-file context","Streaming completion may show incomplete/incorrect suggestions before final token arrives","No built-in filtering for low-confidence suggestions; all completions shown equally"],"requires":["JupyterLab 4.1+","Model provider configured","Inline completion feature enabled in settings"],"input_types":["current cell code context","surrounding cell code","cursor position in editor"],"output_types":["streaming code completion suggestions","ghost text in editor","accepted/rejected completion events"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_7","uri":"capability://automation.workflow.configuration.system.with.multiple.sources.environment.config.files.ui.settings","name":"configuration system with multiple sources (environment, config files, ui settings)","description":"Provides a hierarchical configuration system that reads settings from multiple sources: environment variables, configuration files (jupyter_config.d), and JupyterLab UI settings. Configuration includes model provider selection, API keys, model parameters (temperature, max_tokens), and feature toggles. The system uses a config resolver that merges sources with precedence (UI > env vars > config files > defaults). Configuration is validated against a schema and cached for performance.","intents":["Configure model providers and API keys without editing code","Set model parameters (temperature, max_tokens) globally or per-session","Enable/disable features (inline completion, chat persistence) via settings","Support different configurations across development, staging, production environments"],"best_for":["Teams deploying Jupyter AI across multiple environments","Organizations with security policies requiring config file management","Developers wanting environment-specific model selection"],"limitations":["No built-in config encryption; API keys stored in plaintext in config files — requires external secret management","Configuration changes require notebook restart to take effect; no hot-reload","UI settings stored in JupyterLab's local storage; not synced across multiple machines/browsers","Schema validation errors may be cryptic; limited error messages for invalid configs"],"requires":["JupyterLab 4.0+ or Jupyter Notebook 7.5+","Configuration files in jupyter_config.d/ directory (optional)","Environment variables (optional)"],"input_types":["environment variables (JUPYTER_AI_* prefix)","jupyter_config.d/*.py configuration files","JupyterLab UI settings panel","command-line arguments (if supported)"],"output_types":["merged configuration object","validated model provider settings","feature flags and parameters"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_8","uri":"capability://memory.knowledge.notebook.integration.with.cell.execution.context.and.variable.access","name":"notebook integration with cell execution context and variable access","description":"Integrates with the Jupyter kernel to access notebook execution context: variable values, cell outputs, execution history, and kernel state. AI requests can reference notebook variables (via magic command interpolation or context attachment) and receive responses that can be executed as code or stored as variables. The integration uses the IPython kernel's comm protocol to communicate between the JupyterLab frontend and kernel backend, enabling bidirectional context sharing.","intents":["Reference notebook variables in AI prompts without manual copy-paste","Execute AI-generated code directly in the notebook kernel","Store AI responses as notebook variables for downstream processing","Analyze actual data/outputs from previous cells with AI assistance"],"best_for":["Data scientists building AI-assisted analysis workflows","Developers using notebooks for exploratory programming","Teams using notebooks as executable documentation"],"limitations":["Variable access limited to current kernel session; no cross-kernel variable sharing","Large variable values (DataFrames, arrays) may timeout or exceed LLM context limits when included in prompts","Comm protocol adds ~50-100ms latency per kernel communication","Variable interpolation uses simple string substitution — no type-aware serialization for complex objects"],"requires":["IPython kernel (any version compatible with Jupyter AI)","Jupyter AI kernel extension installed","JupyterLab 4.0+ or Jupyter Notebook 7.5+"],"input_types":["notebook variable names (for interpolation)","cell outputs (for context attachment)","execution history"],"output_types":["variable values injected into prompts","AI-generated code for execution","responses stored as variables"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-jupyter-ai__cap_9","uri":"capability://tool.use.integration.model.parameter.customization.with.provider.specific.settings","name":"model parameter customization with provider-specific settings","description":"Allows users to customize LLM behavior through model parameters (temperature, max_tokens, top_p, etc.) both globally and per-request. Parameters are passed through to the underlying LiteLLM provider, which normalizes them across different provider APIs (OpenAI, Anthropic, Ollama, etc.). The system validates parameters against provider-specific constraints and provides sensible defaults. Configuration can be set via UI settings, config files, or inline in magic commands.","intents":["Adjust model creativity/determinism via temperature without changing prompts","Control response length via max_tokens to fit context windows or reduce latency","Fine-tune model behavior for specific tasks (e.g., low temperature for code generation)","Use provider-specific parameters (e.g., top_k for Ollama) without code changes"],"best_for":["Researchers experimenting with model behavior","Teams optimizing for latency vs quality tradeoffs","Developers building task-specific AI workflows"],"limitations":["Parameter names and ranges vary by provider; no unified parameter schema across all providers","Invalid parameters silently ignored by some providers; no validation errors","Parameter changes require new request; no mid-stream parameter adjustment","No parameter presets or templates for common use cases (e.g., 'creative', 'precise')"],"requires":["Model provider configured","Knowledge of provider-specific parameter names and ranges"],"input_types":["parameter names (temperature, max_tokens, top_p, etc.)","parameter values (floats, integers)","provider-specific parameters"],"output_types":["normalized parameters sent to LiteLLM","provider-specific API calls with parameters","model responses with adjusted behavior"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":28,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","API keys for cloud providers (OpenAI, Anthropic, etc.) OR local Ollama/GPT4All installation","JupyterLab 4.0+ or Jupyter Notebook 7.5+","jupyterlab-chat framework (bundled with Jupyter AI)","JupyterHub for RTC collaboration features","Write access to notebook directory","setuptools knowledge","Understanding of Jupyter AI extension interfaces","Ollama or GPT4All installed and running locally","Sufficient disk space for model downloads (2-50GB per model)"],"failure_modes":["LiteLLM abstraction adds ~50-100ms per request for provider routing and normalization","Custom provider-specific parameters may require direct LiteLLM config; not all advanced features exposed through Jupyter AI UI","Rate limiting and quota management delegated to underlying provider SDKs — no built-in cross-provider rate limiter","RTC collaboration requires JupyterHub or shared Jupyter server; not available in local single-user notebooks","Chat files (.chat format) are proprietary to Jupyter AI; no standardized export to markdown/JSON without custom tooling","Chat history not automatically synced across multiple notebook tabs — each tab maintains separate session state",".chat format is proprietary to Jupyter AI; no standard export to markdown/JSON without custom tooling","Large chat histories (1000+ messages) may cause file I/O slowdowns","Chat files stored in notebook directory; no centralized chat storage or search","No built-in chat deduplication or compression; file size grows linearly with message count","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:03.577Z","last_scraped_at":"2026-05-03T14:00:20.516Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=jupyter-ai","compare_url":"https://unfragile.ai/compare?artifact=jupyter-ai"}},"signature":"sNbqqRhuqD70bDfX5PVzZKttBI8eFMzPWEF5UcnfChDQws+f7TmPcIQWQHi/ZwZIqtPWfnYbkN7Dhls0+rJlCA==","signedAt":"2026-06-22T08:29:15.197Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/jupyter-ai","artifact":"https://unfragile.ai/jupyter-ai","verify":"https://unfragile.ai/api/v1/verify?slug=jupyter-ai","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}