A local-first, multi-provider LLM workbench for chatting with local, remote and cloud AI models. Built with Streamlit for Ollama, OpenAI, Anthropic, Gemini, Groq, OpenRouter, LiteLLM and OpenAI-compatible AI models.
One workbench for local, remote, and cloud AI models.
PeaBox LLM Workbench is a local-first, multi-provider AI workspace built with Streamlit. It provides a single interface for working with Ollama, OpenAI, Anthropic, Google Gemini, Groq, OpenRouter, LiteLLM, Open WebUI, LM Studio, and other OpenAI-compatible endpoints.
Instead of switching between different AI applications, provider dashboards, and local model interfaces, PeaBox gives you one workspace for conversations, model selection, files, vision inputs, reasoning controls, and provider configuration.
v4.0.0 – Multi-Provider Workbench
Working with different LLMs often means using different applications.
You might have:
- Ollama running locally
- Ollama running on a remote server
- OpenAI for one task
- Claude for another
- Gemini for another
- Groq or OpenRouter for experimentation
- LiteLLM acting as a common gateway
- LM Studio running local models
PeaBox brings these environments together.
PeaBox LLM Workbench
│
┌──────────────────┼──────────────────┐
│ │ │
Local Remote Cloud
│ │ │
Ollama SSH Ollama OpenAI / Claude
LM Studio LiteLLM Gemini / Groq
OpenRouter
The idea is simple:
Your models. Your APIs. One AI workbench.
PeaBox provides one interface for multiple LLM providers and runtimes.
Supported connection types include:
- Ollama
- Remote Ollama over SSH
- OpenAI
- Anthropic
- Google Gemini
- Groq
- OpenRouter
- LiteLLM
- LM Studio
- Open WebUI
- Custom OpenAI-compatible endpoints
You can switch between providers and models without changing applications.
Connect directly to an Ollama server running on your computer.
Example:
Provider: Direct Ollama
Base URL: http://localhost:11434
PeaBox can discover models available through the configured Ollama server.
Your model list depends on the models installed in your local Ollama environment.
PeaBox can communicate with Ollama running on another machine through SSH.
This is useful when your models are running on:
- Another workstation
- A Linux VM
- A home lab
- AWS
- Oracle Cloud
- Azure VM
- Other remote infrastructure
Example configuration:
Provider: SSH Ollama
Host:
192.168.x.x
SSH User:
opc
SSH Port:
22
Private Key:
C:\Users\YourName\.ssh\server.key
This allows Ollama to remain on the remote machine while PeaBox communicates with it securely through SSH.
PeaBox can connect to cloud-hosted LLM APIs.
Supported services include:
- OpenAI
- Anthropic
- Google Gemini
- Groq
- OpenRouter
- Mistral
- Together AI
PeaBox also supports OpenAI-compatible APIs, allowing you to connect additional gateways and inference servers without requiring a dedicated implementation for every provider.
A major feature of PeaBox is support for OpenAI-compatible APIs.
Example:
Provider:
OpenAI-compatible
Base URL:
http://localhost:4000/v1
Model:
your-model-name
This makes PeaBox suitable for tools and services such as:
- LiteLLM
- LM Studio
- OpenRouter
- Groq
- Custom gateways
- Self-hosted inference endpoints
PeaBox can discover models exposed by supported providers.
From the Workbench, select:
Discover / Refresh Models
The application retrieves the available model list and makes those models available for selection.
This is especially useful when experimenting with local models because your installed model collection may change frequently.
Conversations are stored locally using SQLite.
PeaBox supports:
- Creating new conversations
- Conversation history
- Reopening previous conversations
- Automatic conversation titles
- Renaming conversations
- Pinning conversations
- Archiving conversations
- Deleting conversations
- Exporting conversations as JSON
Your conversation history remains available after restarting the Workbench.
PeaBox can use uploaded files as additional context for your conversations.
PDF
DOCX
PPTX
XLSX
XLSM
CSV
JSON
TXT
Markdown
XML
HTML
YAML
YML
Examples include:
Python
JavaScript
TypeScript
PowerShell
HTML
Configuration files
Log files
PeaBox extracts supported textual content and adds it to the conversation context.
PeaBox can send images to compatible vision models.
Supported image formats include:
PNG
JPG
JPEG
WEBP
If the selected model supports vision, images can be included alongside the user's prompt.
This can be useful for:
- Screenshot analysis
- UI reviews
- Diagram analysis
- Document image analysis
- Visual debugging
- Image-based questions
Vision capabilities depend on the selected model and provider.
For models that support reasoning or thinking capabilities, PeaBox provides reasoning controls.
Depending on the selected model, available options can include:
Default
Off
Low
Medium
High
Max
This allows you to use lighter reasoning for straightforward requests and higher reasoning levels for more complex tasks where the model supports them.
PeaBox provides access to commonly used generation parameters.
These include:
Temperature
Top P
Top K
Repeat Penalty
Context Tokens
Maximum Output Tokens
Reasoning Level
You can also select:
Use Model Defaults
when you want the model or provider to control its own generation settings.
Not every parameter is supported by every provider or model.
Provider configuration is separated from the main chat workspace.
Open:
Settings & API Vault
From here, you can configure connections using settings such as:
Provider
Base URL
API Key
Default Model
SSH Host
SSH User
SSH Port
Private Key Path
You can also:
- Enable or disable providers
- Save provider configurations
- Test connections
- Discover available models
- Configure preferred models
Keeping provider configuration separate from the main interface keeps the day-to-day chat workspace clean and focused.
PeaBox uses the operating system's credential store through Python's keyring package for provider credentials.
On Windows, API credentials are stored outside the application's regular configuration files.
Non-sensitive configuration and conversation data are stored separately.
Never commit the following to a Git repository:
API keys
SSH private keys
Passwords
Credential exports
.env files containing secrets
The v4 interface is organized around four primary areas:
PeaBox LLM Workbench
├── Chat
│ ├── Conversation History
│ ├── Provider Selection
│ ├── Model Selection
│ └── AI Responses
│
├── Attachments
│ ├── Documents
│ ├── Spreadsheets
│ ├── Source Code
│ └── Images
│
├── Generation
│ ├── Temperature
│ ├── Top P
│ ├── Top K
│ ├── Context
│ └── Reasoning
│
└── Settings & API Vault
├── Providers
├── API Credentials
├── Endpoints
├── Model Discovery
└── Defaults
A typical v4 installation looks like this:
PeaBox-LLM-Workbench/
│
├── app.py
├── providers.py
├── attachments.py
├── storage.py
├── requirements.txt
├── run_windows.bat
├── README.md
│
├── pages/
│ └── 1_Settings.py
│
└── .streamlit/
└── config.toml
The main Streamlit Workbench interface.
It handles:
- Chat UI
- Conversation management
- Provider and model selection
- Attachments
- Generation settings
- AI response display
The provider abstraction layer.
It handles connections to:
- Ollama
- Remote Ollama over SSH
- OpenAI-compatible APIs
- Anthropic
- Supported cloud providers
It also handles model discovery and provider-specific requests.
Processes supported uploaded files and extracts usable content.
Handles:
- SQLite database operations
- Conversations
- Messages
- Application configuration
Provides the dedicated provider configuration and API management interface.
PeaBox stores application data under the user's local profile.
On Windows:
%USERPROFILE%\.peabox_streamlit_llm
Typical files include:
workbench.db
config.json
The SQLite database used for conversation history and related application data.
Stores non-sensitive application and provider configuration.
Credentials are stored separately using the operating system's credential storage mechanism.
You need:
- Windows
- Python 3
- Internet access when using cloud providers
If you want to use local Ollama models, install and configure Ollama separately.
If you want to use remote Ollama over SSH, you will also need access to a remote machine running Ollama and a valid SSH configuration.
Download or clone the repository.
Open the project directory and double-click:
run_windows.bat
The launcher creates the Python virtual environment when required, installs the necessary dependencies, and starts the Streamlit application.
No manual PowerShell virtual environment activation is required.
Create a virtual environment:
py -m venv .venvInstall the dependencies:
.\.venv\Scripts\python.exe -m pip install -r requirements.txtStart PeaBox:
.\.venv\Scripts\python.exe -m streamlit run app.pyStreamlit will display the local Workbench address after startup.
For an Ollama server running locally:
Provider:
Direct Ollama
Set:
Base URL:
http://localhost:11434
Then select:
Discover / Refresh Models
to retrieve the available models.
Open:
Settings & API Vault
Select:
SSH Ollama
Configure:
Host
SSH User
SSH Port
Private Key Path
Save the configuration and test the connection.
PeaBox can then communicate with the remote Ollama instance through SSH.
Select:
LiteLLM
Example endpoint:
http://localhost:4000/v1
Configure:
API Key
Default Model
according to your LiteLLM setup.
Because LiteLLM provides an OpenAI-compatible interface, it can act as a common gateway between PeaBox and multiple underlying LLM providers.
Start the local server from LM Studio.
Configure PeaBox using the OpenAI-compatible endpoint displayed by LM Studio.
For example:
http://localhost:1234/v1
Use the actual address displayed by your LM Studio installation.
Open:
Settings & API Vault
Choose the required provider and configure:
API Key
Base URL
Default Model
Save the connection.
Then use:
Test Connection
or:
Discover Models
before returning to the main chat workspace.
A typical first-run workflow is:
1. Start PeaBox
↓
2. Open Settings & API Vault
↓
3. Configure a provider
↓
4. Save the connection
↓
5. Test the connection
↓
6. Return to Chat
↓
7. Discover models
↓
8. Select a model
↓
9. Start chatting
PeaBox is designed for experimentation.
You can move between:
Local Model
↓
Remote Model
↓
Cloud Model
↓
Another Provider
without changing applications.
For example:
Coding
→ Local coding model
Detailed reasoning
→ Reasoning-capable model
General-purpose work
→ General-purpose cloud model
Fast experimentation
→ Low-latency provider
Model routing
→ LiteLLM
The model remains your choice.
Open the Attachments tab.
Upload one or more supported documents.
You can then ask questions such as:
Summarize these documents.
Compare these two files.
Identify the differences between these requirements.
Create action items from this document.
Explain this source code.
Analyze this spreadsheet.
Document content is added to the model context, subject to the Workbench's extraction limits.
Upload supported source files and ask the selected model to:
Explain this code.
Find potential bugs.
Refactor this function.
Generate unit tests.
Convert this implementation to another language.
Explain the architecture.
PeaBox v4 does not automatically execute generated code.
PeaBox is designed primarily as a local, single-user Workbench.
Keep the following points in mind.
Do not store API keys directly in source files.
Never add SSH private keys to the repository.
Make sure that local runtime files and credentials are excluded.
Recommended entries:
.venv/
__pycache__/
*.pyc
.env
.peabox/
.peabox_streamlit_llm/
.streamlit/secrets.toml
*.key
*.pemDocuments sent to a cloud LLM may leave your computer and be processed by an external service.
For sensitive information, consider using an appropriately controlled local or self-hosted model.
PeaBox can operate with different privacy models depending on the selected provider.
Local Ollama
│
└── Local inference
Remote Ollama
│
└── Your remote infrastructure
Cloud API
│
└── External AI provider
The privacy and data-handling policies of the selected model provider still apply.
Using PeaBox as a local interface does not make an external cloud model local.
Check whether Ollama is running.
Verify the configured base URL:
http://localhost:11434
Then refresh model discovery.
Check:
SSH Host
SSH Username
SSH Port
Private Key Path
Remote Ollama Process
Try connecting to the remote machine using your normal SSH client first.
Verify:
API Key
Base URL
Model Name
Provider Access
Network Connectivity
Use the connection testing option in Settings.
Upgrade pip and reinstall the dependencies:
.\.venv\Scripts\python.exe -m pip install --upgrade pip
.\.venv\Scripts\python.exe -m pip install -r requirements.txtDelete:
.venv
Then run:
run_windows.bat
again.
Your local conversation database is stored separately from the project's virtual environment.
v4 establishes PeaBox as a multi-provider AI Workbench.
Future development areas include:
- Projects and Workspaces
- Persistent Knowledge Base
- Prompt Library
- Model Compare
- Streaming Responses
- Research Mode
- Usage and Cost Analytics
- Artifacts
- Model Benchmarking
- Tool Calling
- Local Data Analysis
- Backup and Restore
The longer-term goal is to evolve PeaBox beyond a multi-LLM chat client into a broader AI productivity Workbench.
Contributions are welcome.
Useful contribution areas include:
- Additional provider adapters
- Attachment processors
- Streamlit UI improvements
- Model discovery improvements
- Conversation management features
- Tests
- Documentation
- Accessibility improvements
- Performance improvements
A typical contribution workflow:
git clone <your-repository-url>
cd PeaBox-LLM-Workbench
git checkout -b feature/my-featureMake your changes, test them locally, and submit a pull request.
Please do not commit:
API Keys
SSH Credentials
Private Keys
Personal Configuration
Conversation Databases
Private Documents
When reporting an issue, include:
- PeaBox version
- Python version
- Operating system
- Provider
- Model
- Relevant error message
- Steps to reproduce the issue
Before sharing logs or screenshots, remove:
API Keys
Tokens
Passwords
SSH Credentials
Private Hostnames or IP Addresses
Sensitive Document Content
Feature ideas are welcome.
A useful feature request should explain:
- The problem you are trying to solve
- The intended workflow
- Why the feature would be useful in PeaBox
- Which providers or models it affects
- An example use case
Before publicly distributing the project as open source, add the appropriate license file to the repository.
For example, if PeaBox is released under the Apache License 2.0, add:
LICENSE
to the root of the repository and update this section accordingly.
PeaBox started with a simple idea:
Imagine a box full of peas. Each pea is an idea or an experiment. On its own, it may be small, but when these ideas come together, they can grow into something useful.
That is what PeaBox is about.
A place to experiment, build, learn, and turn small ideas into practical tools.
PeaBox LLM Workbench is one of those experiments: a practical workspace for exploring local models, cloud AI, self-hosted infrastructure, and different ways of working with LLMs.
If PeaBox LLM Workbench is useful to you:
- ⭐ Star the repository
- 🐛 Report issues
- 💡 Suggest new features
- 🔧 Contribute improvements
- 🍴 Fork it and experiment
Every contribution helps PeaBox grow.
Built for people who want the freedom to choose where, how, and with which model their AI runs.