Skip to content
KNIME Documentation
Main Navigation Get startedBuildWork with KnimeAccount and adminRelease notesDeveloper tools
Community Hub
DevelopersKnime 2.0
Sidebar Navigation

Getting Started

Installation

User Guide

Release Notes

Install Extensions

Building Workflows

Components

Flow Control

Expressions

File Handling

Deployment

Integrated Deployment

Workflow Invocation

Best Practices

Advanced Features

AI Extension

Get Started

Build an Agent

Inject context with RAG

LLM Providers

Tutorials

Summarize product reviews

Product FAQ assistant

Restaurant agent

Your first local agent

Task extractor

Reporting

Kerberos

Extensions

Database

Overview

Tutorials

Read and filter data from a database

Write a transformed dataset to a database

Concepts

Ports and Sessions

Query Generation

Type Mapping

Deprecated Framework

Connecting

Connect: Dedicated Node

Connect: File-Based Database

Connect: Generic DB Connector

Register a JDBC Driver

Install Third-Party Driver Plug-in

Drivers on Hub and Server

Kerberos Constrained Delegation

Reading and Transforming

Read Data

Transform Data Visually

Run a Custom SQL Query

Parameterize a Query

Writing and Modifying

Insert, Update, or Merge

Delete Rows

Bulk Load Data

Create and Remove Tables

Use Transactions

Reference

Connector Node Settings

JDBC Driver Reference

Deprecated Node Mapping

Migrate Deprecated Workflows

Python

Overview

Tutorials

Python Scripting Quickstart

Data App Development Using Plotly

Data Processing

K-AI Scripting Assistant

Data Type Conversion

Batch Processing

Jupyter Integration

Environment Management

Pixi Configuration

Dependency Management

Environment Persistence

Channel Mirrors & Air-Gapped Setups

Conda Migration

Alternative Configurations

Conda and Miniforge Setup

Conda Environment Propagation

Manual Python Configuration

Legacy Node Migration

Concepts

Pixi Backend Architecture

Storage Logic

Python Environments on Executors

Reference

Python Scripting API

Bundled Packages

Executor and Hub Configuration

Troubleshooting Guide

API Reference

Inputs and outputs

Classes

Views

Utility functions

R

Deep Learning

Snowflake

Google Cloud

Azure

AWS

Big Data

Big Data Admin

Big Data Secured Cluster

Databricks

Microsoft Fabric

Power BI

Tableau

Report Designer

H2O

Changelogs

Version 5.12

Version 5.11

Version 5.10

Version 5.9

Version 5.8

Version 5.7

Version 5.6

Version 5.5

Version 5.3

Extensions

Python Integration ​

The Python integration lets you execute scripts within KNIME workflows, providing direct access to the Python ecosystem for data manipulation, analysis, and visualization.

Python workflow: 1. Environment setup, 2. Data ingestion, 3. Script execution.

Tutorials ​

These guides provide end-to-end implementations so you can learn by building functional examples.

  • Python Scripting Quickstart: Install the extension and run your first script using a temporary environment.
  • Data App Development Using Plotly: Build interactive Plotly visualizations and deploy them to KNIME Hub.

Data Processing and Scripting ​

The API of the Python Integration can be found in the Python Script API reference.

  • K-AI Scripting Assistant: Generate, explain, and debug code using the integrated AI assistant.
  • Data Type Conversion: Map data between KNIME tables and Pandas or PyArrow formats.
  • Batch Processing: Process large datasets that exceed your available memory.
  • Jupyter Integration: Load and execute functions from your external .ipynb files.

Environment Management ​

KNIME uses Pixi for environment isolation. Use these resources to configure and manage your local setup.

  • Pixi Configuration: Initialize the Python Environment Provider and create portable environments.
  • Dependency Management: Install and manage the specific Python libraries your project requires.
  • Environment Persistence: Configure permanent storage to avoid re-downloading packages.
  • Channel Mirrors & Air-Gapped Setups: Serve conda channels from internal mirror servers via Pixi's configuration files.
  • Conda Migration: Move your legacy "Conda Environment Propagation" nodes to the Pixi-based provider.

Architecture and Concepts ​

Understand the internal logic behind backend execution and filesystem organization.

  • Pixi Backend Architecture: Learn how lock-file systems differ from traditional Conda environments.
  • Storage Logic: How KNIME manages directory structures and OS-specific paths.
  • Python Environments on Executors: Understand the three environment types available when running workflows on KNIME Executors.

Alternative Configurations ​

Options for legacy environments, manual installations, and third-party managers.

  • Conda and Miniforge Setup: Configure workspace-wide environments via Conda.
  • Conda Environment Propagation: Bundle Conda environments directly within your workflows.
  • Manual Python Configuration: Use local Python binaries or your own custom start scripts.
  • Legacy Node Migration: Port workflows from older Python nodes to the current framework.

Reference and Troubleshooting ​

Technical specifications and fixes for common configuration issues.

  • Python Scripting API: Full reference for the knio and knjupyter modules.
  • Bundled Packages: Review the libraries included in your default environment.
  • Executor and Hub Configuration: Set knime.ini flags, preferences, and REST API parameters.
  • Troubleshooting Guide: Find solutions for SSL errors, path limits, and execution failures.
Pager
Previous pageMigrate Deprecated Workflows
Next pagePython Scripting Quickstart