> ## Documentation Index
> Fetch the complete documentation index at: https://docs.noxus.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Plugins Overview
> What you can build with Noxus plugins — nodes, integrations, triggers, and data sources
Plugins let you extend Noxus without changing core platform code. A single plugin can provide **custom nodes**, **integrations with external services**, **data sources for knowledge bases**, and more — all packaged together, versioned, and deployed independently.
## What you can build
```mermaid theme={null}
mindmap
root((Plugin))
Nodes
Custom logic
AI operations
Data processing
File transformations
Integrations
OAuth connections
API key services
Custom auth flows
Data Sources
Knowledge base sources
Document processors
Triggers
Webhook listeners
Scheduled events
```
### Custom nodes
Nodes are the building blocks of workflows. A plugin can add new node types that appear in the flow editor's palette alongside built-in nodes.
**Examples of what custom nodes can do:**
* Call your internal APIs or microservices
* Run specialized data transformations (PDF parsing, image processing, audio transcription)
* Connect to niche SaaS tools not covered by built-in integrations
* Implement domain-specific business logic (compliance checks, pricing calculations)
* Wrap ML models or AI services with custom pre/post-processing
Each node defines its **inputs**, **outputs**, and **configuration** — the platform handles wiring them into workflows, list iteration, error handling, and execution.
### Integrations
Integrations manage **authentication and credentials** for external services. When your node needs to talk to an external API that requires auth, you define an integration to handle that.
**What integrations provide:**
* A credentials schema that appears in the workspace settings UI
* Credential validation (is the API key valid? has the OAuth token expired?)
* Secure credential storage — the platform encrypts and manages credentials, passing them to your node at execution time
A single plugin can define integrations and nodes that use them together, creating a complete connector for an external service.
### Data sources for knowledge bases
Plugins can provide custom data sources that feed documents into Noxus knowledge bases. This lets you pull content from proprietary systems, internal databases, or specialized document stores into the KB pipeline.
### Triggers
Plugins can define triggers that start workflow runs in response to external events — webhooks from third-party services, scheduled intervals, or custom event sources.
## Plugin structure
A plugin is a Python package with a specific structure:
```
my-plugin/
├── my_plugin/
│ ├── __init__.py # Plugin class + nodes + integrations
│ └── ... # Additional modules
├── pyproject.toml # Dependencies (must include noxus-sdk)
└── manifest.json # Auto-generated on serve/validate
```
The core of a plugin is a class that extends `BasePlugin` and declares what it provides:
```python theme={null}
from noxus_sdk.plugins import BasePlugin, PluginConfiguration
from noxus_sdk.plugins.types import PluginCategory
class MyPluginConfig(PluginConfiguration):
pass # Plugin-level configuration fields go here
class MyPlugin(BasePlugin[MyPluginConfig]):
name = "my-plugin"
display_name = "My Plugin"
version = "1.0.0"
description = "Does amazing things"
category = PluginCategory.GENERAL
author = "Your Name"
def nodes(self):
return [MyCustomNode, AnotherNode]
def integrations(self):
return [MyServiceIntegration]
```
## Plugin lifecycle
Scaffold your plugin with `noxus plugin create` or manually set up the package structure.
Implement nodes, integrations, and configuration. Test locally with `noxus plugin serve`.
Run `noxus plugin validate` to check your manifest, node definitions, and config schemas.
Push to a Git repository or upload the package. Install from the Noxus UI.
Monitor plugin status, view logs, and update by restarting with a new source version.
## How plugins run
Plugins run as **isolated processes** managed by the Plugin Server. Each plugin gets its own Python virtual environment and runs as a FastAPI server on localhost. The platform forwards execution requests to the plugin, and the plugin returns results.
```mermaid theme={null}
graph LR
WF[Workflow Engine] -->|"execute node"| PS[Plugin Server]
PS -->|"HTTP forward"| PP["Plugin Process
(your code)"]
PP -->|"result"| PS
PS -->|"result"| WF
```
This isolation means:
* Your plugin can use **any Python dependencies** without conflicting with the platform
* Plugin crashes don't affect the core platform
* Plugins are **sandboxed** — they access platform resources (files, credentials, models) through controlled interfaces
## SDK and CLI
The `noxus-sdk` package provides everything you need:
| Tool | Purpose |
| ------------------------ | ------------------------------------------------------ |
| `BasePlugin` | Base class for plugin definitions |
| `BaseNode` | Base class for custom nodes |
| `BaseIntegration` | Base class for integrations |
| `RemoteExecutionContext` | Runtime context with credentials, file helpers, config |
| `noxus plugin create` | Scaffold a new plugin from a template |
| `noxus plugin validate` | Validate plugin structure and manifest |
| `noxus plugin serve` | Run your plugin locally for development |
| `noxus plugin package` | Package your plugin as a `.tar.gz` for upload |
Step-by-step tutorial from zero to deployed plugin
Deep dive into how the plugin system works