Requirements

• Node.js ≥ 20.11.0 (LTS)
• pnpm ≥ 9.15.0 (Required)
• API keys for LLM providers (Anthropic, OpenAI, etc.)

🚀 Getting Started

For a comprehensive guide, see the Getting Started Guide.

Installation

1. Clone the Repository:

   git clone https://github.com/AgentDock/AgentDock.git
   cd AgentDock
   

1. Install pnpm:

   corepack enable
   corepack prepare pnpm@latest --activate
   

1. Install Dependencies:

   pnpm install
   

   pnpm run clean-install
   

4. Configure Environment: Create an environment file (.env or .env.local) based on .env.example:

   # Option 1: Create .env.local
   cp .env.example .env.local
   
   # Option 2: Create .env
   cp .env.example .env
   

1. Start Development Server:

   pnpm dev
   

Deploy the Open Source Client

Click the button above to deploy the AgentDock Open Source Client directly to your Vercel account.

💡 What You Can Build

1. AI-Powered Applications - Custom chatbots with any frontend - Command-line AI assistants - Automated data processing pipelines - Backend service integrations

2. Integration Capabilities - Any AI provider (OpenAI, Anthropic, etc.) - Any frontend framework - Any backend service - Custom data sources and APIs

3. Automation Systems - Data processing workflows - Document analysis pipelines - Automated reporting systems - Task automation agents

✨ Build Anything!

AgentDock provides the foundation to build almost any AI-powered application or automation you can imagine. We encourage you to explore the framework, build innovative agents, and contribute back to the community. Let's build the future of AI interaction together!

🔧 Example Implementations

Example implementations showcase specialized use cases and advanced functionality:

Demos

Dr. Gregory House: A diagnostic reasoning powerhouse that orchestrates search, deep_research, and pubmed tools in a multi-stage workflow to tackle complex medical cases using methodical investigation techniques that rival expert diagnosticians.

https://github.com/user-attachments/assets/50c766dc-fc65-481c-aad2-9a71169c7b28

</br>

Cognitive Reasoner: Multi-stage reasoning engine that orchestrates seven specialized cognitive tools (search, think, reflect, compare, critique, brainstorm, debate) in configurable workflows to systematically deconstruct and solve complex problems with human-like reasoning patterns.

https://github.com/user-attachments/assets/279a4e48-a980-4f83-becb-5e039fe10c56

</br>

History Mentor: Immersive educational agent combining vectorized historical knowledge with search capabilities and dynamic Mermaid diagram rendering to create authentic learning experiences that visualize complex historical relationships and timelines on demand.

https://github.com/user-attachments/assets/56e80a15-eac3-452b-aa8b-efe7b7f3360c

</br>

Calorie Vision: Vision-based nutritional analysis system that combines computer vision with structured data extraction to deliver precise macro and micronutrient breakdowns from food images, functioning like a nutritionist that can instantly quantify meal composition without relying on manual input.

https://github.com/user-attachments/assets/6b4e71cf-accc-4c18-bb42-7bc5ad2f37e4

Configurable Determinism

Configurable determinism is a cornerstone of AgentDock's design philosophy, enabling you to balance creative AI capabilities with predictable system behavior:

• AgentNodes are inherently non-deterministic as LLMs may generate different responses each time
• Workflows can be made more deterministic through defined tool execution paths
• Developers can control the level of determinism by configuring which parts of the system use LLM inference
• Even with LLM components, the overall system behavior remains predictable through structured tool interactions
• This balanced approach enables both creativity and reliability in your AI applications

Deterministic Workflows

AgentDock fully supports the deterministic workflows you're familiar with from typical workflow builders. All the predictable execution paths and reliable outcomes you expect are available, with or without LLM inference:

Non-Deterministic Agent Behavior

With AgentDock, you can also leverage AgentNodes with LLMs when you need more adaptability. The creative outputs may vary based on your needs, while maintaining structured interaction patterns:

Non-Deterministic Agents with Deterministic Sub-Workflows

AgentDock gives you the best of both worlds by combining non-deterministic agent intelligence with deterministic workflow execution:

This approach enables complex multi-step workflows (potentially involving hundreds of deterministic steps implemented within tools or as connected node sequences) to be invoked by intelligent agent decisions. Each workflow executes predictably despite being triggered by non-deterministic agent reasoning.

For more advanced AI agent workflows and multi-stage processing pipelines, we're building AgentDock Pro - a powerful platform for creating, visualizing, and running complex agent systems.

TL;DR on Configurable Determinism

Think of it like driving. Sometimes you need the AI's creativity (like navigating city streets - non-deterministic), and sometimes you need reliable, step-by-step processes (like following highway signs - deterministic). AgentDock lets you build systems that use both, choosing the right approach for each part of a task. You get the AI's smarts and predictable results where needed.

🔐 Environment Configuration Details

The AgentDock Open Source Client requires API keys for LLM providers to function. These are configured in an environment file (.env or .env.local) which you create based on the provided .env.example file.

LLM Provider API Keys

Add your LLM provider API keys (at least one is required):

```bash

LLM Provider API Keys - at least one is required

ANTHROPIC_API_KEY=sk-ant-xxxxxxx # Anthropic API key OPENAI_API_KEY=sk-xxxxxxx # OpenAI API key GEMINI_API_KEY=xxxxxxx # Google Gemini API key DEEPSEEK_API_KEY=xxxxxxx # DeepSeek API key GROQ_API_KEY=xxxxxxx # Groq API key ```

API Key Resolution

The AgentDock Open Source Client follows a priority order when resolving which API key to use:

1. Per-agent custom API key (set via agent settings in the UI)
2. Global settings API key (set via the settings page in the UI)
3. Environment variable (from .env.local or deployment platform)

Tool-specific API Keys

Some tools also require their own API keys:

```bash

Tool-specific API Keys

SERPER_API_KEY= # Required for search functionality FIRECRAWL_API_KEY= # Required for deeper web search ```

For more details about environment configuration, see the implementation in src/types/env.ts.

Using Your Own API Keys (BYOK)

AgentDock follows a BYOK (Bring Your Own Key) model:

1. Add your API keys in the settings page of the application
2. Alternatively, provide keys via request headers for direct API usage
3. Keys are securely stored using the built-in encryption system
4. No API keys are shared or stored on our servers

📦 Package Manager

This project requires the use of pnpm for consistent dependency management. npm and yarn are not supported.

🧰 Components

AgentDock's modular architecture is built upon these key components:

• BaseNode: The foundation for all nodes in the system
• AgentNode: The primary abstraction for agent functionality
• Tools & Custom Nodes: Callable capabilities and custom logic implemented as nodes.
• Node Registry: Manages the registration and retrieval of all node types
• Tool Registry: Manages tool availability for agents
• CoreLLM: Unified interface for interacting with LLM providers
• Provider Registry: Manages LLM provider configurations
• Evaluation Framework: Core components for agent assessment
• Error Handling: System for handling errors and ensuring predictable behavior
• Logging: Structured logging system for monitoring and debugging
• Orchestration: Controls tool availability and behavior based on conversation context
• Sessions: Manages state isolation between concurrent conversations

For detailed technical documentation on these components, see the Architecture Overview.