By Gabor on September 18, 2023
Deepnote AI vs. Jupyter AI: Which fits your data workflow better?
Both Deepnote and Jupyter notebooks harness the potential of generative AI to enhance data work efficiency. While they share some functionalities, significant distinctions exist in their user experience, design philosophy, and integration into daily workflows. In this article, we'll dive deep into comparing these two AI assistants.
A terminology heads-up: In Deepnote, we use the term 'blocks' for what Jupyter refers to as 'cells'. However, they functionally serve the same purpose.
Jupyter AI is available as a free JupyterLab extension. To get started, you can either install this extension or opt for the command line magic utility. However, the latter option won't provide the chat interface experience. For a fair comparison, we'll focus on the complete JupyterLab version.
To activate its capabilities, you'll first select a model for your AI assistant. Jupyter AI supports 7 major model providers, including the likes of OpenAI, Anthropic, and SageMaker. Remember, before leveraging these models, you'll need their respective Python packages. Once that's done, configure the provider’s API key in your environment to complete the setup.
One consideration worth noting about Jupyter AI is the need to procure your own API key from the chosen LLM service. While this offers flexibility in choice, it also means you bear the costs associated with querying the provider. The exact expenses related to these services can sometimes be hard to keep track of, especially when when you’re exploring each service’s diverse functionalities.
In stark contrast to Jupyter AI, Deepnote AI offers a hassle-free setup. Simply sign up for our free trial, launch a new notebook, and dive into its full range of features immediately. Furthermore, our Team and Enterprise plans generously include all AI functionalities we’ll be discussing below, with zero restrictions. This means users can freely harness these features without the looming worry of additional charges.
While Deepnote AI currently doesn't allow model selection (though it's on our roadmap!), we've collaborated with industry leaders to ensure unparalleled service. We've partnered with OpenAI for interactive conversational assistance and Codeium for precision in code completion suggestions.
Code completion (Copilot)
Jupyter AI currently lacks an integrated feature for AI-powered code suggestions during typing.
Right from the start, Deepnote AI empowers users with intuitive code suggestions. When you initiate a Python block and begin typing, swift, context-aware code suggestions quickly and seamlessly integrate into your workflow. This "ghost text" feature has become indispensable for many of our users, particularly those who spend a significant portion of their day working with Python.
But our code completion isn’t exclusive to Python pros: it’s also incorporated into our native SQL blocks, enabling analysts to efficiently craft relevant queries.
Jupyter AI presents several methods for generating code using natural language prompts, each with its set of advantages and challenges.
Chat window extension: This feature allows users to request code through a chat interface. The resulting code, alongside its explanation, appears in the chat thread. However, to execute the code, users must manually copy, paste, and run it in their notebook. Such a process can be cumbersome, particularly when swift iterations are necessary. Moreover, Jupyter AI does not inherently recognize the notebook's content, leading it to sometimes suggest general or incorrect solutions. For instance, a suggested code block referencing a non-existent 'games' dataframe can result in errors. This demands constant code review and edits before execution.
Magic utility: The magic utility offers another avenue for code generation, but it lacks contextual awareness of the Python notebook environment. Consequently, straightforward instructions, like 'remove NaNs from data,' won't function. Instead, users need to input more detailed prompts to procure the appropriate suggestions, a practice which may end up taking more time than writing the code itself.
/generate command: By employing the
/generate command in the chat, users can instruct Jupyter AI to craft an entirely new notebook based on their prompt. While this sounds promising, there are significant challenges:
The entire generation process remains opaque to the user, offering no avenue to intervene or guide the AI.
The output notebook tends to be generic, lacking customization to a user's specific data or workspace. Consequently, running any block after the first one often results in errors. The AI's approach of merely generating blocks without execution prevents it from identifying and rectifying such issues.
Deepnote AI supports code generation through a dual-mode approach:
This intuitive feature allows code generation directly within your workflow. Initiate a new Python block and select
Generate with Deepnote AI. Alternatively, tap the Deepnote AI button within the block actions menu.
The AI's suggestions populate the subsequent block automatically, eliminating tedious copy-pasting.
More impressively, Deepnote AI’s contextual understanding ensures that these suggestions are not only accurate but also executable without errors. It gleans information from your notebook's entire content, outputs, and variable explorer. For example, a simple instruction to ‘filter out sports games’ will have the AI deftly identifying the correct column (
Genre) and its corresponding value (
Sports). This means you can keep your instructions conversational, without reiterating previously entered data or commands.
Autonomous Deepnote AI
Picture this as an adept virtual colleague, not just obediently following commands but also comprehending intricate tasks, structuring them, and implementing them autonomously.
Kick off with a basic prompt in a new notebook, and watch Deepnote AI strategize and execute. Whether it's drafting SQL queries to fetch data, orchestrating diverse data transformations, or visualizing outcomes using Python – it does it all. Post-execution, it further distills the results into a high-level summary and even offers subsequent course of actions. Plus, if any hiccup arises during execution, Deepnote AI strives to rectify it autonomously. And all these actions unfold live; nothing is hidden from you. If ever you wish to pause the AI or supply it with intricate follow-up instructions, the platform is all ears.
This groundbreaking feature is still in its Beta phase, but it’s coming soon to general release. And we can’t wait to share its full prowess with you!
Jupyter AI facilitates code editing via its chat interface, but there are steps and potential pitfalls to consider.
Include selection option
Begin by highlighting the segment of code you want to modify. Using the
Include selection option, incorporate this segment into your prompt. The chat thread will present you with the revised code, which you then need to manually copy and integrate into your original code block.
Replace selection feature
Replace selection tool in the chat window promises a more streamlined editing process by instantly replacing highlighted code with AI-generated suggestions, it has its drawbacks. For instance, it often mishandles formatting by inadvertently including markdown elements, leading to errors when executing the code.
Deepnote AI, in contrast, has transformed code editing into a seamless process:
- One-click access: Navigate to the block you wish to modify and click on the AI button.
- Effortless editing: Simply select
Editand enter your desired modifications. Thanks to Deepnote AI's innate context-awareness, it instantly offers an edited version.
- Instant execution: Without any manual copy-pasting, you can immediately run the revised code.
Deepnote AI emphasizes fluidity and accuracy, ensuring you spend less time on repetitive tasks and more on productive work.
You can use the chat window to request code explanations. Similar to code editing, you will need to select the part of code you wish to understand and then type out your request.
In Deepnote, explain are one of the standard AI actions available in all code blocks. Simply press
Explain and you will receive a concise interpretation of the whole block. As an extra convenience, you can quickly add this explanation to your notebook with one click as well, which adds additional contextual information to your notebook for readers.
Jupyter AI doesn’t have a dedicated AI interface for code-fixing. If you need help with an error, you need to copy paste the original code and error message and ask for potential fixes.
Once you get a fix suggestion, you will need to copy-paste back and run it. This makes Jupyter AI quite cumbersome to use for quick problem solving.
Deepnote AI automatically offers an option to fix any bugs that may pop up. Simply click on the
Fix with Deepnote AI button to receive potential fix solutions. If you like the suggestions, you can run it with one click as well. This is a radically faster way to fix bugs on the fly!
A major strength of Deepnote AI is its access to the notebook context. For example, when faced with an error due to a variable name discrepancy, Deepnote AI was able to immediately recognize and correct it. Jupyter AI, in comparison, might merely suggest adjusting the variable name without pinpointing the exact issue. This contextual awareness in Deepnote AI not only streamlines troubleshooting, but also significantly reduces the time required to resolve issues.
Extending contextual awareness
Jupyter AI offers a unique feature: the ability to learn from your local files and use this newfound context to answer specific questions about documents. To kickstart this process, you can utilize the
/learn command in the chat window and point the AI to a desired local folder. The data from these files gets transformed and stored in a local vector database through embedding.
However, there's a prerequisite: you'll need to connect with an embedding model from a chosen model provider (and this comes with its own set of costs). As a demonstration, I used this feature to teach Jupyter AI about this very blog article, leveraging OpenAI's embedding model.
While this capability offers an interactive way to delve into a local knowledge base, it's not without its challenges:
- Separation from main workflow: The feature stands somewhat isolated. To access this augmented context, you must specifically use the
/askcommand. There isn’t a seamless way to integrate the content from the learnt documents into your main notebook work experience.
- Manual updates required: If documents get updated or new ones are added, you need to run the learning process again. The system lacks an automatic refresh mechanism to keep the embeddings updated.
Deepnote AI's strength lies in its integrated understanding of your project context. Soon, this will encompass local files, ensuring your AI assistance is grounded in the entirety of your work. Furthermore, we're working on extending the ‘vision’ of Deepnote AI to encompass insights from all projects within your workspace. Instead of manual data feeding, Deepnote AI will naturally assimilate the maximum amount of relevant knowledge from your workspace, optimizing its guidance accordingly.
A prime example of this approach can be seen in our AI code completion for SQL blocks. Rather than solely depending on the content of the current notebook, it gleans insights from relevant SQL blocks across all notebooks in your workspace. In one instance, our AI copilot automatically filled out a full JOIN condition for me. Why? It recognized from other projects that this was a frequently used and relevant join — precisely what I was aiming for! The takeaway? The more you engage with a specific data source across various projects, the more nuanced and tailor-made the AI suggestions become.
Jupyter AI adopts a one-size-fits-all approach regarding access to your data. Once initialized, it becomes challenging to discern what content is actually processed and sent to the selected AI model providers. A glaring concern is the absence of a central control to prevent AI access to code outputs. This could inadvertently reveal sensitive row-level data to third-party services, posing potential privacy risks.
In contrast, Deepnote AI champions robust privacy controls. The system empowers workspace administrators with granular controls over its features. Not only can they disable specific features such as code completion, but they can also limit data access to block content alone, ensuring outputs—potentially containing sensitive information—are never shared with LLMs. This granularity emphasizes Deepnote AI's commitment to prioritizing user privacy.
👍 Jupyter AI
➕ Model diversity: Provides access to an array of different models.
➕ Code generation: Offers a variety of ways to generate code using natural language prompts, including the option to create a notebook from scratch.
➕ Chat interface: While the chat window approach might not be the most streamlined for notebook interactions, it offers a distinct interface for posing broader, more general questions.
➕ Learn about local files: Presents an easy way to ask specific questions about a local knowledge base.
👍 Deepnote AI
➕ Seamless integration: Designed to organically fit into your data workflow, removing the need for chat windows or repetitive copy-pasting. Activate AI features contextually, and get actionable outputs as blocks.
➕ Intelligent context recognition: Uses notebook content, variables, schemas, and outputs to provide context-aware assistance. Allows for natural, conversational prompts.
➕ Autonomous mode: Functions as a virtual collaborator—plans, executes tasks, and independently corrects itself.
➕ AI code completion: Offers advanced code completion for enhanced productivity.
➕ Diverse AI features: 'Edit', 'Explain', and 'Code Fix' are all first-class AI features with dedicated interfaces.
➕ SQL block assistance: Assists in crafting relevant SQL queries.
➕ Privacy prioritized: Comprehensive integration with stringent privacy controls.
➕ User-friendly: No installation, API keys, or hidden costs.
Share this post