Interoperability with more notebook formats, Git upgrades, GitLab support, & bring your own environment

Convert more file formats to Deepnote projects and vice versa

The Deepnote convert CLI previously supported bi-directional conversion between Deepnote projects and Jupyter notebooks. Based on popular demand, we shipped bidirectional, lossless notebook conversions between Deepnote, Jupyter, Quarto, Percent, and Marimo.

We’ve also included a smarter CLI with automatic format detection and a new -- format flag to make the work more seamless. This helps increase interoperability across projects and reduce lock-in, in the true spirit of open-source!

That means you can move work both ways:

• Bring your previous projects back into Deepnote without losing momentum, and enjoy the extended functionality Deepnote offers!
• Convert a Deepnote project into any of the above notebook formats when you need to share, archive, or run elsewhere

You can now also export projects and notebooks directly from the VS Code extension.

We will continue working on .deepnote format portability to better integrate it with the ecosystem - let us know if you have any suggestions!

Git integration updates

On our Git integration front, we’ve reworked the three core actions: pull, commit, and push. Everything got a more polished UI, plus a set of improvements that make day-to-day collaboration smoother.

Support for merge conflict resolution

Previously, pull only supported fast-forward updates, which meant it worked only when branches weren’t divergent. Now you can pull even when branches diverge, and if Git can’t resolve conflicts automatically, Deepnote will show a conflict resolution modal where you can keep either your local changes or the incoming changes.

Pull with stash

No need to commit local changes just to pull anymore, even if they touch files updated on the remote. Deepnote can pull with stash, and if conflicts occur (between your local-only commits and remote, or between the stash and remote), you can resolve them in the same conflict resolution flow.

Commit and push

The commit and push modal got a big refresh:

• Preview your changes in a clean diff editor
• Exclude files from the commit
• Switch to a new branch directly from the modal
• Get prompted to open a PR after a successful push

We’ve also included a set of smaller improvements, including a clearer branch selector (with more intuitive new-branch creation) and a one-click shortcut to open your repository on GitHub directly from the integration menu.

GitLab support in Git integration

GitLab is now fully supported in Deepnote’s Git integration in the Files section - not just for exports.

You can now:

• Connect GitLab repositories to folders
• Pull changes from the remote
• Commit and push local changes
• Switch between branches

One key difference compared to GitHub: for GitLab, Deepnote performs Git actions on your behalf, whereas GitHub uses Deepnote’s GitHub App. As a result, the setup flow is slightly different. Full instructions are available in the new GitLab integration documentation.

Python & SQL language servers in the VS Code extension

The Deepnote VS Code extension now ships with Python and SQL language servers, which means your editor can actually understand your code and your schema.

What you get out of the box:

• Diagnostics
• Type hints and method signature info
• Autocomplete for functions and variables
• Autocomplete for table and column names, powered by your real database schema

This is included in the newly released extension version 1.3.0, along with the other improvements shipped before the holidays.

Bring your own virtual environment to the VS Code Extension

You can now use the Deepnote VS Code extension with both managed and existing (external) Python environments. The environment list now clearly shows the type, and the extension can detect and reuse virtual environments you already have (poetry, uv, conda, native venv) instead of forcing you to create a new one. This comes in handy if, for instance, you have a custom or opinionated way of installing dependencies. In case the Deepnote toolkit is missing, the extension will guide you through installing it directly into the selected environment with clear progress and logs. We also improved safety and reliability around environment migration, cleanup, and toolkit installation to avoid conflicts or accidental deletion.

Bring your own AI model & GitLab export & new admin powers

Bring your own AI model

Enterprise workspaces can now connect their own OpenAI-compatible endpoints to power Deepnote Agent - giving you full control over the AI provider behind your data analysis workflows.

This is especially valuable for organizations that need to:

• Meet compliance or regional data requirements with specific AI providers
• Leverage proprietary or fine-tuned models optimized for specific use cases
• Keep data within specific infrastructure boundaries

Setting it up is straightforward:

• Head to Settings & Members → AI tab and click Add model
• Provide your endpoint URL, model ID, and API key
• Set it as your workspace default, and Agent will use your custom model for all analysis tasks

Learn more about custom AI models

Export notebooks to GitLab

Great news for GitLab users - you can now export your notebooks directly to GitLab repositories, just like you've been able to with GitHub.

Whether you need to back up your work, maintain audit trails for compliance, or trigger automated pipelines, exporting to GitLab is now just a few clicks away:

• Open any project, click the Version history icon in the top right, then select Connect Git repository and choose GitLab (you'll connect your GitLab account if you haven't already)
• Pick your repository, specify the target branch and path, and choose whether to include outputs
• Export manually with the Commit & push button, or set up automatic exports whenever you create a new version

Check out the docs to get started with GitLab exports.

New admin powers

We've shipped a suite of new workspace settings that give admins more control over security and permissions - perfect for enterprise teams with strict governance requirements.

• Restrict email invites to your domain: Admins can now limit workspace and project invites to only email addresses matching the workspace owner's domain, preventing accidental external invites
• Disable incoming connections workspace-wide: Turn off the ability for project editors to enable incoming connections, giving admins full control over external access points
• Control private project creation: Disable the creation of new private projects in your workspace while keeping existing ones intact
• Set default permissions for public projects: Choose what permissions workspace members get on newly created public projects - from Full access down to View only

These controls give you the flexibility to create the right permission environment suited to your organization's specific security and collaboration needs.

PySpark DataFrames in charts

Chart with the full power of your Spark cluster

Here’s what’s new: you can now build charts directly from PySpark DataFrames, which means you’re no longer limited to small samples. Whether your dataset has a few million rows or hundreds of millions, you can explore it visually without extra preprocessing.

Here's what's new:

• No more sampling limits – Build charts from your complete PySpark DataFrames, whether your dataset has a few million rows or hundreds of millions
• Fast interactive preview – While setting up your chart, see instant previews as you try different dimensions, filters, and colors
• Full cluster power on demand – Click Apply and Spark runs the complete aggregation across your entire dataset using your full cluster.

Check out this quick video to see PySpark DataFrames in charts:

You can now create the same rich, interactive charts you’re used to, now backed by the scale of Spark. From quick category breakdowns to stacked sales-over-time views, everything runs natively on your cluster.

This release completes our native Spark support in Deepnote—both data tables and charts now work seamlessly with your complete datasets, giving you an end-to-end Spark experience.

Introducing Deepnote Agent

We're excited to announce Deepnote Agent, bringing together workflows data teams rely on and context-aware AI agents, powered by frontier LLMs agentic capabilities.

Mainstream AI chat tools lack essential data context and critical data tooling - such as the capability to run large-scale SQL queries directly from your cold storage, generate customizable charts, or build interactive data dashboards. Legacy solutions like Jupyter provide basic AI extensions but fall short of delivering meaningful analytics beyond simple LLM API calls.

These limitations typically force data teams to create costly, custom in-house solutions to use LLMs effectively with private data.

Deepnote Agent addresses this problem by deeply integrating your actual data schema from 100+ data sources directly into an intuitive generative AI workspace. Available in Beta starting today, Deepnote Agent can now edit, add, and remove blocks at any point within your notebook, fully aware of your project's context. This marks a significant upgrade from our earlier AI, which could only append blocks sequentially.

What's new

• Full notebook editing - Make changes anywhere, not just at the bottom
• Context-aware modifications - Agent understands your entire project when making edits
• Multi-task execution - Refactor entire analyses, document your notebook, or fix multiple issues with a single prompt

How it works

Agent interprets your intent and creates a transparent, step-by-step plan before executing each task systematically. Whether it's something simple like "rename variable df," polishing a notebook for presentation, or one-shotting a complex analysis from a single prompt, the agent maintains full awareness of your project context while working.

Agent is built to provide confidence and control:

• Before-and-after diff view - See exactly what changed with clear visual comparisons
• One-click revert - Undo any unwanted edits instantly
• Ask mode - Get guidance without modifications when you want to brainstorm, ask questions about your data, or learn more about Deepnote features

Agent operates through a new sidebar chat interface that keeps your AI conversations persistent alongside your notebook. Expand it for longer conversations or collapse it when you want to focus on your analysis.

Try the Beta!

The Beta is available to all users on paid plans starting today. We'll be adding more functionality continuously and would love to hear your feedback! Head over to our docs page to learn more.

Codestral code completions

We've also upgraded our code completion engine with a powerful new foundation! Your autocomplete suggestions are now powered by Codestral from Mistral, a model built specifically for code completion. This ensures you continue getting the same fast, contextually aware suggestions you're used to, while giving us a more robust platform for future improvements. The transition happens seamlessly in the background, so you can keep coding without missing a beat.

Unlimited charting & reference tags in prompts

Unlimited charting: no more 10,000 row limit

We've just shipped one of our most requested features: unlimited charting for large datasets!

For too long, our 10,000 row limit on charts has been a major frustration point. We know you've had to work around this limitation by pre-aggregating your data, applying filters, or sampling before creating visualizations. Those days are officially over.

You can now create charts directly from Pandas DataFrames with millions of rows without any preprocessing. Whether you're working with sales data, user analytics, or any large dataset, simply select your columns and chart away - no more workarounds needed.

Check out this quick video to see unlimited charting in action:

For datasets larger than 1 million records, we've implemented a smart preview mode to keep your charting experience responsive. You'll see an initial chart built from sampled data, allowing you to quickly experiment with different visualizations and configurations. Once you're satisfied with your chart setup, simply press Apply to run the aggregations on your complete dataset.

This enhancement works seamlessly with all our existing chart types, giving you the freedom to explore your data without constraints.

We're also actively working on bringing the same unlimited capabilities to Spark DataFrames, which will unlock charting for even larger datasets with hundreds of millions of records. More on that soon!

Reference tags in prompts

@References bring more precision to every Deepnote AI prompt in Workspace Home. Now, when you type @, you can add integrations like @bigquery - sales data or modules such as @sales_prediction directly into your request. Deepnote AI uses these references to anchor its answers in the exact context you choose, making insights more relevant and actionable.

Referencing integrations and modules in your prompt ensures that Deepnote AI draws from the most trusted and approved sources in your workspace. For example, referencing a module tells Deepnote AI to use your team's official logic and metric definitions, while referencing an integration ensures it bases answers on the right data source.

By guiding Deepnote AI with references, you get answers that follow your team's established rules and standards. No more generic responses - every insight is grounded in your specific context and trusted sources.

Soon, you'll be able to use references in the AI chat inside notebooks too, bringing this same level of accuracy and control wherever you're working with Deepnote AI.

Choose AI provider & PySpark data tables

Native table view for PySpark DataFrames

Spark users, this one's for you! PySpark DataFrames now work seamlessly with our interactive table views, giving you a proper way to explore your massive datasets beyond the basic df.show() output. See how it works in this quick demo.

If you've been working with Spark, you know the drill - df.show() gives you a quick minimalistic peek at your data, but that's about it. Not exactly ideal when you're trying to understand what you're working with. Now your PySpark DataFrames get the full Deepnote treatment: just return your DataFrame on the last line of your code block, and you'll see it displayed in our rich table view with sorting, filtering, column management, and conditional formatting.

Here's the smart part: we pull 10,000 records into a preview mode so you can explore quickly, but when you apply transformations like filtering or sorting, we push those operations back to Spark to work with your complete dataset. This means you get snappy exploration of massive data while still having the power to manipulate everything when needed.

This update is also paving the way for something we're really excited about: native charting support for arbitrarily large datasets. Soon you'll be able to create visualizations that run aggregations on the backend, so you can chart massive datasets without worrying about row limits or pre-filtering. We're bringing this to both Spark and Pandas DataFrames.

Choose your AI provider

We're giving workspace admins on paid plans more control over their AI experience! You can now set the default AI provider for your entire workspace, choosing between OpenAI and Anthropic to best fit your team's needs.

Here's how it works: head to Settings & members → Project Settings to select your preferred provider. Once set, all new AI interactions in your workspace will use your chosen default. This means you can standardize your team's AI experience while still maintaining the flexibility to switch providers when needed.

For new paying customers, we've made Anthropic the default AI provider. Anthropic offers enhanced capabilities that we think will make your data science workflows even more powerful. If you're an existing paying customer and want to try Anthropic, you can easily make the switch in your workspace settings.

This is just the beginning of giving you more choice and control over your AI tools. We're planning to add more providers to this list, so you'll have even more options to choose from based on your team's specific needs.

AI support in the file editor & new workspace home

Deepnote AI in the file editor with Streamlit support

We're excited to introduce AI editing capabilities to the file editor, bringing a powerful new way to create and modify your Python files. Check out this short video to see it in action:

Need to create or modify a Streamlit app? Simply click the AI button in the upper right corner of the file editor and describe what you want. Our AI assistant will generate or edit the entire file, which you can review in a convenient diff view. Once you're satisfied with the suggested changes, just accept them and watch your Streamlit preview update immediately with your new code.

Not satisfied with the results? No problem - iterate with follow-up prompts until it's perfect! Just like in notebooks, the AI understands your project context to provide relevant assistance.

This enhancement makes Streamlit app development accessible to everyone - even those with limited Python knowledge. If you've been hesitant to try Streamlit before, now is the perfect time! Embrace "vibe-coding" and let AI do the heavy lifting in your data app development.

New workspace home

We’ve redesigned the workspace home to help you get more done, faster—and stay connected to your team’s work.

You can now create new projects with AI in a snap! Just describe the project you want to build in the prompt bar—Deepnote AI will generate a ready-to-use project for you.

The new workspace home also makes it easy to pick up where you left off and discover what’s happening across your workspace.

• Recently updated: Quickly access notebooks you've been working on
• Shared with me: See projects others have shared directly with you
• Published apps: Browse all data apps published in your workspace
• Favorites: Jump into your pinned projects with just one click

This redesigned experience is available now for all workspaces. We've built it to reduce time spent searching for projects, giving you more time to focus on what matters most—your data work.

AI chat & AI code completion in files & input block improvements

AI chat: your data thinking partner

While our AI has always been excellent at executing tasks, we recognize that sometimes you need a thinking partner rather than a doer. That's why we're introducing a dedicated AI chat interface for more exploratory conversations about your data challenges. Check out our quick video below to see it in action!

Located in the bottom right corner of your projects, this new chat window creates a space where you can freely brainstorm ideas, discuss analytical approaches, and explore potential solutions before committing to code. It's perfect for those moments when you're still formulating your thoughts or need guidance on the best way forward.

The chat interface is fully integrated with your project environment - it understands your data, notebooks, and overall context. Ask it how to tackle a specific analysis problem, request suggestions for improving your notebooks, or explore different methodological approaches, all through natural conversation.

We've also enhanced it with comprehensive knowledge about Deepnote itself. Need help finding a feature or understanding how something works? The AI can quickly answer your Deepnote-related questions, saving you a trip to the documentation and keeping you focused on your work.

This new chat interface is just the first step in our effort to create a unified and more powerful AI agent experience in Deepnote. We don't want to spoil surprises, but here's a tiny sneak peek: what if the AI could turn your messy exploration into a structured, executable data story with a single prompt? That's all we'll say for now - watch this space!

AI code completion: now in the file editor

We've brought our popular AI code completion to the file editor! Now you can enjoy intelligent code suggestions while editing Python scripts, including Streamlit apps.

This enhancement gives you the same great experience you're used to in notebooks. The completions are lightning-fast as you type and contextually aware - understanding your project files and integrations to provide relevant suggestions. It's particularly handy when building Streamlit apps that connect to data - code for accessing your files and setting up data connections will be automatically suggested.

Working on scripts outside of notebooks just got a whole lot smoother. Whether you're building a Streamlit application or maintaining utility files, our AI assistant is ready to help speed up your coding.

Input block improvements

We've shipped several upgrades to our interactive inputs based on your requests! These improvements give you more flexibility when building data apps.

First, we're introducing a new date range input block. Now you can select both start and end dates from a single widget instead of managing them separately. We've also added relative date options like "last 7 days" or "last month," making it easier for your stakeholders to navigate dashboards.

You can now define specific default values for your input blocks too. Simply go to the block settings and set a default value. When someone opens your app in 'run app from scratch' mode, they'll see these defaults right away, giving you better control over their initial experience.

We've also added support for empty states in select inputs. Previously, you always needed to have a value selected in dropdown menus. Now you can enable the 'allow empty values' setting, letting users remove all selections when needed. This is particularly useful for workflows that start from a blank state or for removing filters. Remember: if you enable empty selection, make sure your code or SQL can handle None values.

Query chaining & checkbox inputs

Chained SQL

Build complex SQL queries the notebook way - one block at a time! Our new chained SQL feature lets you break down massive queries into simple, manageable steps without worrying about memory limitations. See how it works in this quick demo:

If you've ever built a complex SQL query using Common Table Expressions (CTEs), you know the challenges. Large subqueries can crash with out-of-memory errors, forcing you to upgrade hardware or implement tedious workarounds. Debugging means commenting out sections or running separate queries, then stitching everything back together - it's a headache.

Chained SQL solves this elegantly. When running SQL queries, you'll now see two output options:

• The familiar DataFrame mode that returns full results
• Our new query preview mode that returns a lightweight query object (just 100 rows)

The magic happens when you reference these query objects in subsequent SQL blocks.

Here's a simple example: first, we query our USERS table with query preview mode. Then, in a separate block, we query the USERS_AB table the same way.

Finally, in a third block, reference both query objects to join them together and see which user was in which variant - all with clean, simple SQL in each block.

We automatically build CTEs in the background, linking your blocks together while keeping memory usage low. Your blocks stay clean and focused, showing only the SQL you need for each step. Need to see the full query? Just click "Show compiled SQL" in block actions.

When you've perfected your query chain and want the complete results, simply switch the final block to DataFrame mode. This gives you complete control over when to pull data into memory.

Chained SQL brings the notebook philosophy to complex queries - build incrementally, debug easily, and manage memory efficiently. Visit our documentation for all the details.

Checkbox inputs

We've added a useful new feature to make your notebooks and apps more interactive: checkbox inputs! These new input blocks let you easily toggle Boolean values on and off with a simple click. Creating one is straightforward - just click on the Input button in the notebook footer and select Checkbox input. You can customize it with an optional display name that shows on your apps and configure the label text that appears next to the checkbox. They're perfect for filtering data on Boolean columns, or adding toggle options to your interactive dashboards.

Snowflake key-pair authentication

We've added support for Snowflake's key-pair authentication, giving you a more secure way to connect to your Snowflake data. This authentication method eliminates the need for password-based access by using cryptographic keys instead. Simply generate your private and public key pair, register the public key with your Snowflake user account, and use your private key when connecting from Deepnote. It's more secure and just as convenient once set up. Check out our documentation for step-by-step instructions on generating keys and configuring your connection.

Redesigned native charts & AI with modules

Revamped chart builder

We've completely rebuilt our charting experience from the ground up! Charts are now simpler, faster to create, and more powerful than ever before. See all the improvements in action in this quick video:

The first thing you'll notice is our cleaner layout. Instead of jumping between three separate tabs to configure your charts, everything is now in one place. Data, style, and global settings are all neatly organized on a single screen, making chart creation faster and more intuitive.

Creating specific chart types is now much more straightforward. We've added 14 purpose-built chart templates, each with just the options you need for that specific visualization. Want a pie chart or histogram? Just select it and you'll see only the relevant settings - nothing more, nothing less.

Composite charts have been totally reimagined. Say goodbye to managing complex layers - now you can simply add additional series to your chart for powerful combinations. We've even added a dedicated chart type specifically for building these multi-series visualizations.

You'll discover plenty of quality-of-life improvements too. Changing colors and renaming series is now just a click away. Our AI support has been enhanced to handle more complex requests, including building combo charts for you. There are many more small touches waiting for you to discover.

Go ahead and try out the new charting experience - we think you'll find it makes data visualization in Deepnote faster and more enjoyable than ever. Check out our documentation for all the details.

Deepnote AI now uses your modules

Last week we introduced modules - a game-changer for making notebooks truly composable. This week, we're taking it a step further by bringing modules into Deepnote AI.

Here's why this matters: when you build a semantic layer with modules (defining your KPIs and metrics in a trusted, consistent way), you're not just helping your team - you're also teaching Deepnote AI. Now when you ask analytical questions, the AI first checks your module library for existing trusted definitions before attempting to calculate anything from scratch. It will automatically select the right module, adjust parameters based on your question, and build the analysis on that foundation.

This is a major leap for AI accuracy. By using your predefined modules, the AI avoids reinventing metrics or potentially getting calculations wrong. Your curated modules create guardrails that keep analyses consistent and trustworthy - whether it's a teammate digging into a deeper analysis or a stakeholder asking a quick business question.

The combination of modules and AI means you get both consistency and speed - the best of both worlds. Check out our blog article to learn more about creating modules for your semantic layer.

Modules: turn notebooks into reusable workflows

We're incredibly excited to introduce modules - a feature we believe will fundamentally change how your team works with notebooks! They let you package your existing best work - those tried and true data cleaning routines and trusted SQL queries - into reusable modules that anyone can import into their notebooks. No more reinventing the wheel with each new analysis. See how it works:

Until now, sharing code or queries across projects meant copy-pasting them across notebooks, making updates tedious and inconsistencies inevitable. Modules offer an elegant solution to these challenges - build once and use everywhere.

Creating analytical building blocks for your team is straightforward: click the module publish button, select which blocks to export as the desired outputs and you're done. You can also add parameters to your module simply by adding regular input blocks - just like when you create interactive apps.

Importing modules is also easy: click on the module button in the footer, find the module you need, configure any parameters, and run it - all results seamlessly integrate into your current notebook. What makes this especially powerful is that each module runs in its own separate environment - none of the code interferes with your current notebook. You just get back the clean output variables you need, keeping your analysis tidy and focused.

Why are modules kind of a big deal? Because they open up so many possibilities.

• Create a semantic layer for KPIs so everyone calculates metrics like churn rate the same way.
• Build modular ETL pipelines that are easier to maintain and debug.
• Package different ML models as modules and cleanly compare them in sequence.

We're already using modules ourselves to organize our data workflows, and honestly, we can't imagine going back. Check out our detailed guide and explore our example notebook to see our approach to building a semantic layer.

Modules are available in your workspace now. Visit our documentation for the details and start building your first module today.