Forem: Rock

Open Source AI Agent for Remote PC Control: The OpenClaw Alternative Built Into LangBot

Rock — Sun, 15 Mar 2026 12:23:34 +0000

Open Source AI Agent for Remote PC Control — The OpenClaw Alternative Built Into LangBot

✨ What is LangTARS?

LangTARS is a powerful OpenClaw alternative and native plugin for LangBot, inspired by the loyal and reliable robot TARS from the movie Interstellar.

As a versatile AI agent for remote computer control, LangTARS allows you to remotely command your Mac, Windows, or Linux machine directly through your favorite messaging apps like Telegram, Discord, DingTalk, and WeChat! If you've been looking for an OpenClaw-like computer use agent that integrates seamlessly into your existing chatbot framework, LangTARS is the perfect solution.

💡 Deploy LangBot, and you can experience LangTARS instantly! No extra standalone agent installation needed—just get it with one click from the plugin marketplace.

🤖 The LangBot Ecosystem

LangTARS is just ONE plugin in the massive LangBot ecosystem. LangBot is a leading open source chatbot framework designed for connecting LLMs to messaging platforms.

Multi-platform bot integration: Native support for Telegram, Discord, WeChat, DingTalk, Lark, LINE, Slack, and more.
Multi-model LLM chatbot: Works flawlessly with OpenAI, Claude, Gemini, DeepSeek, and local models.
Rich Plugin Marketplace: Access over 30+ plugins for endless functionality.
Advanced Features: Pipeline-based message processing, RAG support, and multi-agent workflows.
Self-hosted AI: Total control over your data and deployments.
AI Workflow Integrations: Connect LangBot to platforms like Dify, n8n, Langflow, and Coze. LangBot can act as the messaging frontend for your complex AI workflows, meaning LangTARS + Dify/n8n = powerful automation!

Get started with LangBot:

Easiest: LangBot Cloud
Self-host: uvx langbot@latest
Documentation: docs.langbot.app
GitHub: github.com/langbot-app/LangBot (15k+ stars)

🎯 What Can It Do?

As a comprehensive automation tool, just send a message, and the AI will handle your task automation and browser automation:

You Say	AI Does
`!tars open Reddit in Chrome, post a thread with the title "Hello from LangTARS" and say hi`	🌐 Automatically controls Chrome to open Reddit and publish a post
`!tars organize my desktop files`	📁 Automatically categorizes and moves files
`!tars open the browser and search for today's AI news`	🌐 Opens a browser, searches the web, and summarizes the news
`!tars create a meeting note for our marketing sync`	📝 Automatically creates a markdown note file
`!tars check system memory and CPU`	💻 Uses MCP tools to get computer status

🚀 Why Choose LangTARS?

1️⃣ LangBot Native Plugin, Out of the Box

Instead of deploying a complex standalone agent, you can easily deploy AI bot capabilities right where you already chat.

# Deploy LangBot with one command
uvx langbot@latest

# Install LangTARS from the plugin market, configure your LLM, and start using!

No complex configuration, no extra deployment. LangBot users can experience OpenClaw-style computer control directly!

2️⃣ Intelligent Task Planning, Autonomous Execution

Your Command → Understand Needs → Make a Plan → Execute Step-by-Step → Feedback Results

The AI assistant thinks like a human and automatically breaks down complex tasks using integrated MCP tools!

3️⃣ Multi-Browser Support for Web Automation

Browser	macOS	Windows	Linux
Playwright (Headless)	✅	✅	✅
Safari	✅	-	-
Chrome	✅	✅	✅
Edge	-	✅	-
Firefox	-	-	✅

4️⃣ Security-First Design

🚫 Dangerous Command Interception — Automatically blocks commands like rm -rf /
📂 Workspace Isolation — Restricts file operations to safe directories
📋 Command Whitelist — Configurable allowed commands
👤 User Access Control — Restricts usage to specific authorized users

📱 Quick Start

Step 1: Deploy LangBot

🚀 Fastest way to start: Use LangBot Cloud — deploy your LangBot instance in one click, no server needed! Install LangTARS from the plugin marketplace and start controlling your computer immediately.

Alternative for power users (Self-hosted):

uvx langbot@latest

Step 2: Configure Chat Platform

Follow the documentation to configure your Telegram bot, WeChat bot, or Discord bot.

Step 3: Install LangTARS

Search for LangTARS in the plugin marketplace and install it.

Step 4: Start Chatting

!tars Hello, tell me what you can do

📱 Recommendation: Use it on Telegram or Discord for the best interactive experience!

🎮 Common Commands

Command	Function
`!tars <Task Description>`	Execute a task
`!tars stop`	Stop the current task
`!tars what`	Check execution status
`!tars reset`	Reset the conversation
`!tars help`	Show help

🌟 Project Information

Item	Information
GitHub	github.com/langbot-app/LangTARS
Language	Python 100%
License	CC BY-NC-ND 4.0
Platforms	macOS / Windows / Linux

🔗 Related Links

📖 LangBot Documentation: docs.langbot.app
💬 Issue Feedback: GitHub Issues
⭐ Support with a Star: GitHub

7 Open-Source Frameworks for Deploying AI Bots to Messaging Platforms in 2026

Rock — Sat, 28 Feb 2026 12:41:09 +0000

I spent the last few weeks evaluating open-source frameworks for a project that needed an AI chatbot running on multiple messaging platforms simultaneously — specifically Discord, Telegram, and WeChat.

The existing "best chatbot framework" listicles are mostly outdated (still recommending Dialogflow and BotKit in 2026?), so I figured I'd share what I actually found useful.

What I Was Looking For

My requirements were pretty specific:

Multi-platform: One codebase, multiple messaging apps (not just web chat)
LLM-native: Built for connecting to GPT, Claude, DeepSeek, etc. — not NLU-era intent matching
Self-hosted: Full control over data and deployment
Actually maintained: Regular commits, active community, recent releases

Here's what made the cut, organized by use case.

1. Botpress — The Enterprise Visual Builder

GitHub: 14.5k ⭐ | Language: TypeScript | License: MIT

Botpress has been around since 2017 and has evolved significantly. It now offers a visual flow builder, built-in NLU, and native integrations with Slack, Telegram, Messenger, and Microsoft Teams.

Strengths:

Polished visual editor — genuinely usable by non-developers
Built-in knowledge base and RAG
Large plugin ecosystem
Good documentation

Weaknesses:

No WeChat, QQ, LINE, or DingTalk support
Cloud-first model — self-hosting is possible but clearly not the priority
Some advanced features gated behind paid plans

Best for: Teams that want a visual builder and primarily target Western messaging platforms.

2. Rasa — The NLU Veteran

GitHub: 21k ⭐ | Language: Python | License: Apache 2.0

Rasa is the OG of open-source chatbots. It's battle-tested in enterprise environments and offers the most sophisticated NLU pipeline of any open-source tool.

Strengths:

Most mature conversation management (stories, rules, forms)
Strong NLU with entity extraction
Extensive enterprise track record

Weaknesses:

Designed for the pre-LLM era — bolting on GPT feels awkward
Steep learning curve
Recent pivot to Rasa Pro (commercial) has fragmented the open-source offering
Multi-platform support requires custom connectors

Best for: Enterprise teams with existing Rasa deployments or complex NLU requirements.

3. Wechaty — The WeChat Specialist

GitHub: 22.5k ⭐ | Language: TypeScript | License: Apache 2.0

If your primary target is WeChat, Wechaty is the standard. It provides a clean RPA-style SDK for WeChat automation and has expanded to support WhatsApp, Lark, and a few other platforms.

Strengths:

Best WeChat integration available
Clean, developer-friendly API
Strong community in the Chinese developer ecosystem

Weaknesses:

WeChat-centric — other platform support is secondary
No built-in AI/LLM integration (BYO everything)
WeChat's anti-bot measures can cause issues

Best for: Projects where WeChat is the primary or only platform.

4. Flowise — Visual LLM Chains

GitHub: 49k ⭐ | Language: TypeScript | License: Apache 2.0

Flowise gives you a drag-and-drop UI for building LangChain flows. It was acquired by Workday in 2025, which gives it enterprise backing but raises questions about long-term open-source commitment.

Strengths:

Beautiful visual builder for LLM chains
Direct LangChain integration
Easy to prototype RAG applications

Weaknesses:

Not really a "messaging bot" framework — it's an LLM orchestrator
Messaging platform integrations are limited and feel bolted-on
Post-acquisition direction unclear

Best for: Prototyping LLM workflows and RAG applications, not multi-platform messaging bots.

5. LangBot — Multi-Platform IM + LLM Hub

GitHub: 15.4k ⭐ | Language: Python | License: MIT

This one surprised me. LangBot (formerly QChatGPT) focuses specifically on the gap between AI backends and messaging platforms. It supports 10+ IM platforms including QQ, WeChat, Discord, Telegram, Slack, LINE, Lark, and DingTalk — which is more than anything else I found.

Strengths:

Widest messaging platform coverage (both Chinese and international)
Native integration with Dify, n8n, Langflow, Coze as "runners" — so you can use visual workflow tools for AI logic
Also supports direct OpenAI/Claude/Gemini connections
Pipeline architecture — different bots can use different AI backends
Cross-process plugin isolation (plugins can't crash the main process)
WebUI for management
Listed in Dify's official docs as the recommended way to connect Dify to messaging platforms

Weaknesses:

Documentation is bilingual (Chinese/English) but English docs are thinner
Newer project — smaller Western community compared to Botpress/Rasa
Plugin ecosystem is still rebuilding after a major architecture change

Best for: Anyone who needs to deploy an AI bot to multiple messaging platforms, especially if you're using Dify, n8n, or Langflow for AI orchestration.

6. AstrBot — The Community-Focused Alternative

GitHub: 18.3k ⭐ | Language: Python | License: MIT

AstrBot is LangBot's closest competitor and actually has more GitHub stars. It supports QQ, WeChat, Telegram, and Feishu with a simpler setup process.

Strengths:

Easy to get started
Active Chinese developer community
Good plugin ecosystem for entertainment use cases
Dify integration

Weaknesses:

Fewer international platform integrations (no Discord, Slack, LINE, DingTalk)
More focused on consumer/entertainment than B2B
Less modular architecture

Best for: Chinese IM platforms with a focus on community/entertainment bots.

7. n8n + Custom Connectors — The DIY Approach

GitHub: 177k ⭐ | Language: TypeScript | License: Sustainable Use License

n8n isn't a chatbot framework per se, but its AI Agent nodes combined with messaging triggers (Telegram, Slack, Discord) make it a legitimate option. You build the entire flow visually.

Strengths:

Most flexible — literally any workflow logic
400+ integrations for business logic
Strong AI Agent support with tool calling
Huge community

Weaknesses:

No native WeChat, QQ, or LINE support
Each platform needs its own trigger setup
Not designed for high-throughput chat scenarios
Conversation memory management is manual

Best for: Teams already using n8n who want to add AI chat capabilities to a few platforms.

Comparison Matrix

Feature	Botpress	Rasa	Wechaty	Flowise	LangBot	AstrBot	n8n
Discord	✅	❌	❌	❌	✅	❌	✅
Telegram	✅	❌	❌	❌	✅	✅	✅
Slack	✅	❌	❌	❌	✅	❌	✅
WeChat	❌	❌	✅	❌	✅	✅	❌
QQ	❌	❌	❌	❌	✅	✅	❌
LINE	❌	❌	❌	❌	✅	❌	❌
Lark/Feishu	❌	❌	✅	❌	✅	✅	❌
DingTalk	❌	❌	❌	❌	✅	❌	❌
Visual Builder	✅	❌	❌	✅	via Dify/n8n	❌	✅
LLM-Native	✅	❌	❌	✅	✅	✅	✅
Self-Hosted	⚠️	✅	✅	✅	✅	✅	✅
Dify Integration	❌	❌	❌	❌	✅	✅	✅
Plugin System	✅	❌	❌	❌	✅	✅	✅

My Takeaway

The chatbot landscape has split into two worlds:

Western-focused tools (Botpress, Rasa) have good docs and polished UIs but barely support Asian messaging platforms. They were built for a pre-LLM world and are retrofitting AI capabilities.

Asia-origin tools (LangBot, AstrBot, Wechaty) cover WeChat/QQ/DingTalk but are less known in Western developer circles. The newer ones (LangBot, AstrBot) are LLM-native from the ground up.

Workflow tools (n8n, Flowise) aren't chatbot frameworks but are increasingly used as AI backends — especially when paired with a dedicated messaging layer.

If I had to pick one today for a project spanning both Chinese and international platforms, I'd probably go with LangBot + Dify. The Dify integration is officially documented and supported on both sides, and the platform coverage is unmatched. For Western-only deployments, Botpress is the safe choice.

What's your setup? I'm curious what other people are using — drop a comment.

This comparison is based on my evaluation in February 2026. Stars, features, and project directions change fast in this space.

Deep Dive into the LangBot Plugin System: Process Isolation, Event-Driven Hooks & Component Architecture

Rock — Sat, 28 Feb 2026 10:36:48 +0000

Most chatbot frameworks call their "plugin system" a glorified dynamic import of Python modules. LangBot 4.0 takes a harder but more principled approach — every plugin runs in its own process, communicating with the host through a structured JSON-RPC-style protocol.

This article dissects the system from source code, end to end.

Overall Architecture: A Three-Layer Process Model

LangBot's plugin system consists of three cooperating process layers:

Each layer has a distinct responsibility:

LangBot Main Process: Runs business logic (message pipelines, platform adapters, model invocations), connects to Runtime via PluginRuntimeConnector.
Plugin Runtime: The orchestration layer — discovers, launches, and manages all plugin subprocesses, routes requests from the main process to the appropriate plugin.
Plugin Subprocesses: Each plugin runs in its own Python process, communicating with Runtime via stdio pipes.

Why Three Layers Instead of Two?

The intuitive design would have the main process manage plugin processes directly. LangBot adds the Runtime layer for deployment flexibility:

Local development: Main process spawns Runtime as a child via stdio (zero config)
Docker production: Runtime runs as a separate container, connected via WebSocket
Windows compatibility: Since Windows asyncio has incomplete stdio subprocess support, it automatically falls back to WebSocket

The same codebase — no config changes — adapts from development to production.

Communication Protocol: JSON-RPC-Style Request/Response

All cross-process communication runs on a unified protocol layer. The core data structures are minimal:

# Request
class ActionRequest(pydantic.BaseModel):
    seq_id: int    # Sequence number for matching request/response
    action: str    # Action name
    data: dict     # Payload

# Response
class ActionResponse(pydantic.BaseModel):
    seq_id: int
    code: int           # 0 = success
    message: str
    data: dict
    chunk_status: str   # "continue" | "end" (streaming support)

The Handler class is the system's core abstraction, acting as both RPC client and server:

class Handler:
    async def call_action(self, action, data, timeout=15.0) -> dict:
        """Actively call an action provided by the peer, wait for response"""
        self.seq_id_index += 1
        request = ActionRequest.make_request(self.seq_id_index, action.value, data)
        future = asyncio.Future()
        self.resp_waiters[self.seq_id_index] = future
        await self.conn.send(json.dumps(request.model_dump()))
        response = await asyncio.wait_for(future, timeout)
        return response.data

    @action(SomeAction.DO_SOMETHING)
    async def handle_something(data: dict) -> ActionResponse:
        """Register an action for the peer to call"""
        return ActionResponse.success({"result": "ok"})

Key design points:

seq_id-based request/response matching enables full-duplex concurrent calls
Streaming responses via chunk_status for long-running operations like command execution
Large messages auto-chunk (stdio: 16KB / WebSocket: 64KB per chunk)
File transfer uses a separate base64 chunking mechanism

Action Enums: Clear API Contracts

The system defines all cross-process calls through four enum groups:

# Plugin → Runtime (plugin-initiated requests)
class PluginToRuntimeAction:
    REGISTER_PLUGIN = "register_plugin"
    SEND_MESSAGE = "send_message"        # Send message to a platform
    INVOKE_LLM = "invoke_llm"           # Call an LLM
    SET_PLUGIN_STORAGE = "set_plugin_storage"  # Persistent storage
    # ...

# Runtime → Plugin (runtime-dispatched commands)
class RuntimeToPluginAction:
    INITIALIZE_PLUGIN = "initialize_plugin"
    EMIT_EVENT = "emit_event"
    CALL_TOOL = "call_tool"
    EXECUTE_COMMAND = "execute_command"
    SHUTDOWN = "shutdown"
    # ...

# LangBot Main → Runtime
class LangBotToRuntimeAction:
    INSTALL_PLUGIN = "install_plugin"
    EMIT_EVENT = "emit_event"
    LIST_TOOLS = "list_tools"
    # ...

# Runtime → LangBot Main
class RuntimeToLangBotAction:
    GET_PLUGIN_SETTINGS = "get_plugin_settings"
    SET_BINARY_STORAGE = "set_binary_storage"
    # ...

This makes API boundaries crystal clear — what a plugin can and cannot do is defined entirely by these enums.

Plugin Lifecycle

A plugin goes through these stages from installation to execution:

1. Discovery

On startup, Runtime scans the data/plugins/ directory:

async def launch_all_plugins(self):
    for plugin_path in glob.glob("data/plugins/*"):
        if not os.path.isdir(plugin_path):
            continue
        task = self.launch_plugin(plugin_path)
        self.plugin_run_tasks.append(task)

Directory names follow the {author}__{name} convention, each containing a manifest.yaml and plugin code.

2. Launch

Runtime spawns an independent subprocess for each plugin:

async def launch_plugin(self, plugin_path: str):
    python_path = sys.executable
    args = ["-m", "langbot_plugin.cli.__init__", "run", "-s", "--prod"]

    ctrl = StdioClientController(
        command=python_path,
        args=args,
        working_dir=plugin_path,  # Each plugin runs in its own directory
    )
    await ctrl.run(new_plugin_connection_callback)

Key detail: The subprocess working directory is set to the plugin's own directory — natural filesystem isolation.

3. Registration

After starting, the plugin process actively registers itself with Runtime:

# Runtime-side registration handler
async def register_plugin(self, handler, container_data, debug_plugin=False):
    plugin_container = PluginContainer.from_dict(container_data)
    # Fetch plugin settings from the main process
    plugin_settings = await self.context.control_handler.call_action(
        RuntimeToLangBotAction.GET_PLUGIN_SETTINGS, {...}
    )
    # Initialize the plugin (send config)
    await handler.initialize_plugin(plugin_settings)
    # Store the plugin container
    self.plugins.append(plugin_container)

4. Running

Once in INITIALIZED state, the plugin can receive events, tool calls, and command executions.

5. Shutdown

async def shutdown_plugin(self, plugin_container):
    # 1. Notify the plugin to shut down gracefully
    await plugin_container._runtime_plugin_handler.shutdown_plugin()
    # 2. Close the communication connection
    await plugin_container._runtime_plugin_handler.conn.close()
    # 3. Kill the subprocess
    if handler.stdio_process is not None:
        handler.stdio_process.kill()
        await asyncio.wait_for(handler.stdio_process.wait(), timeout=2)

Component System: Four Extension Types

A LangBot plugin isn't a single hook function — it's a component container. A single plugin can provide multiple component types simultaneously:

EventListener

The most fundamental extension — listen for events in the message pipeline:

from langbot_plugin.api.definition.components.common.event_listener import EventListener
from langbot_plugin.api.entities.events import PersonNormalMessageReceived
from langbot_plugin.api.entities.context import EventContext

class MyListener(EventListener):
    @EventListener.handler(PersonNormalMessageReceived)
    async def on_person_message(self, ctx: EventContext):
        event = ctx.event
        # Modify the user message before it reaches the LLM
        event.user_message_alter = "Answer in poetry: " + event.text_message

        # Or block further processing
        # ctx.prevent_default()
        # ctx.prevent_postorder()

Supported events cover the full message lifecycle:

Event	Trigger
`PersonMessageReceived`	Any private message received
`GroupMessageReceived`	Any group message received
`PersonNormalMessageReceived`	Private message deemed processable
`GroupNormalMessageReceived`	Group message deemed processable
`NormalMessageResponded`	LLM response completed
`PromptPreProcessing`	Prompt preprocessing stage

Event propagation supports two interruption modes:

prevent_default(): Skip default behavior (e.g., skip the LLM call)
prevent_postorder(): Stop subsequent plugins from running

Tool

Tools for LLM Function Calling:

from langbot_plugin.api.definition.components.tool.tool import Tool

class WeatherTool(Tool):
    async def call(self, params: dict, session, query_id: int) -> str:
        city = params.get("city", "Beijing")
        # Call weather API...
        return f"{city}: Sunny, 25°C"

Tool metadata (name, description, parameter schema) is defined in a companion YAML manifest file. LangBot automatically converts this into the Function definition that LLMs understand.

Command

User-triggered commands via !command, with subcommand support:

from langbot_plugin.api.definition.components.command.command import Command

class MyCommand(Command):
    def __init__(self):
        super().__init__()

        @self.subcommand("hello", help="Say hello")
        async def hello(self, ctx):
            yield CommandReturn(text="Hello from plugin!")

        @self.subcommand("status", help="Show status")
        async def status(self, ctx):
            yield CommandReturn(text="All systems operational.")

Command results are returned via AsyncGenerator, providing natural streaming output.

KnowledgeRetriever

A multi-instance component for connecting external knowledge bases:

from langbot_plugin.api.definition.components.knowledge_retriever.retriever import KnowledgeRetriever

class MyRetriever(KnowledgeRetriever):
    async def retrieve(self, context) -> list:
        results = await self.search_external_db(context.query)
        return [RetrievalResultEntry(content=r) for r in results]

KnowledgeRetriever is a polymorphic component — a single retriever class can spawn multiple instances, each with independent configuration. This allows users to connect multiple different external knowledge bases.

SDK API: What Plugins Can Do

Plugins gain rich capabilities through the LangBotAPIProxy inherited by BasePlugin:

class LangBotAPIProxy:
    # Message operations
    async def send_message(self, bot_uuid, target_type, target_id, message_chain)

    # Model invocation
    async def get_llm_models(self) -> list[str]
    async def invoke_llm(self, model_uuid, messages, funcs=[], extra_args={})

    # Persistent storage (plugin-level isolation)
    async def set_plugin_storage(self, key, value: bytes)
    async def get_plugin_storage(self, key) -> bytes

    # Workspace storage (cross-plugin shared)
    async def set_workspace_storage(self, key, value: bytes)
    async def get_workspace_storage(self, key) -> bytes

    # System info
    async def get_langbot_version(self) -> str
    async def get_bots(self) -> list[str]
    async def list_plugins_manifest(self) -> list

The storage API design is worth noting: Two levels of KV storage — plugin_storage (plugin-private) and workspace_storage (globally shared), storing data as bytes (base64-serialized in transit). Simple but flexible enough.

Event Dispatch Mechanism

The complete path from main process to plugin:

Key source code:

async def emit_event(self, event_context, include_plugins=None):
    for plugin in self.plugins:
        if plugin.status != RuntimeContainerStatus.INITIALIZED:
            continue
        if not plugin.enabled:
            continue

        # Pipeline-level plugin filtering
        if include_plugins is not None:
            plugin_id = f"{plugin.manifest.metadata.author}/{plugin.manifest.metadata.name}"
            if plugin_id not in include_plugins:
                continue

        resp = await plugin._runtime_plugin_handler.emit_event(
            event_context.model_dump()
        )

        event_context = EventContext.model_validate(resp["event_context"])

        # Plugin requested propagation stop
        if event_context.is_prevented_postorder():
            break

    return emitted_plugins, event_context

The include_plugins parameter enables pipeline-level plugin binding — different message processing pipelines can use different subsets of plugins.

Installation & Distribution

Plugins support three installation sources:

Local upload: .lbpkg files (actually zip archives containing manifest.yaml and code)
Marketplace: Install from LangBot Space online
GitHub Release: Download from a GitHub repository's Release assets

The installation flow:

async def install_plugin(self, source, install_info):
    yield {"current_action": "downloading plugin package"}
    # 1. Fetch and extract the plugin package (unzip)
    plugin_path, author, name, version = await self.install_plugin_from_file(plugin_file)

    yield {"current_action": "installing dependencies"}
    # 2. Install dependencies (pip install -r requirements.txt)
    pkgmgr_helper.install_requirements(requirements_file)

    yield {"current_action": "initializing plugin settings"}
    # 3. Initialize configuration
    await self.context.control_handler.call_action(
        RuntimeToLangBotAction.INITIALIZE_PLUGIN_SETTINGS, {...}
    )

    yield {"current_action": "launching plugin"}
    # 4. Launch the plugin process
    task = self.launch_plugin(plugin_path)

The entire process reports progress via AsyncGenerator, enabling real-time installation status in the frontend.

Developer Experience

The SDK provides a complete developer toolchain:

# Initialize a new plugin
lbp init

# Add a component
lbp component add

# Run locally for debugging
lbp run

# Package for publication
lbp publish

Debug mode has a particularly clever design: the developer's plugin connects to the running Runtime via WebSocket (instead of stdio), meaning you can hot-reload plugin code without restarting LangBot. Debug plugins are specially marked in the UI and protected from accidental deletion.

Comparisons with Other Systems

vs Dify Plugins

Dify's plugin system (dify-plugin-daemon) shares the process isolation philosophy with LangBot, but the focus differs:

Dify: Plugins extend workflow node types (Tool, Model, Extension) — designed for AI application orchestration
LangBot: Plugins extend the message processing pipeline (Event, Tool, Command, KnowledgeRetriever) — designed for instant messaging scenarios

LangBot's EventListener component provides a capability Dify lacks — injecting logic at any stage of message processing.

vs MCP (Model Context Protocol)

MCP is a standardized protocol for AI tool invocation. LangBot's Tool component and MCP services overlap functionally, but serve different purposes:

MCP: A universal "AI calls external capabilities" protocol, usable by any LLM application
LangBot Tool: Deeply integrated with message processing context, with access to session info, user identity, etc.

In practice, LangBot natively supports MCP — users can configure MCP servers directly in LangBot without writing plugins. LangBot's Tool component is for scenarios requiring access to LangBot's internal context.

Design Decisions Explained

Why process isolation instead of threads/coroutines?

Plugin code quality is unpredictable; a segfault shouldn't crash the entire service
Dependency isolation: different plugins may depend on different versions of the same library
Resource control: you can set per-plugin process resource limits

Why JSON instead of Protobuf/MessagePack?

Debug-friendly: developers can directly read communication logs
Natively supported in Python, no extra dependencies
The performance bottleneck isn't serialization (plugin call frequency is far below database queries)

Why stdio over WebSocket by default?

stdio requires no network stack — lower latency
Simpler process lifecycle management (child processes auto-cleanup when parent exits)
WebSocket is only used where stdio isn't supported (Docker, Windows)

Conclusion

LangBot's plugin system is a production-grade, process-isolated, event-driven component framework for extensibility.

Its core design principles:

Safety first: Process isolation ensures plugins can't destabilize the main service
Deployment flexibility: Dual stdio/WebSocket modes adapt to all environments
Developer-friendly: Complete SDK, CLI, and debug support
Component-based: Four component types cover the major extension needs

If you're interested in developing LangBot plugins, start with the plugin development docs, or browse existing plugins on the marketplace for inspiration.

Originally published on LangBot Blog. Star us on GitHub!

How to Connect DeepSeek R1 to WeChat, Discord & Telegram in 5 Minutes (FREE)

Rock — Sat, 28 Feb 2026 10:36:12 +0000

DeepSeek has taken the AI world by storm. Its R1 reasoning model rivals OpenAI's o1 but is open-source and significantly cheaper.

However, the official DeepSeek app currently only supports "AI Search" in WeChat, and direct integration into group chats or private workflows is limited.

What if you could have a fully functional DeepSeek R1 bot in your WeChat groups, Discord servers, and Telegram chats right now?

With LangBot, you can. And it takes less than 5 minutes.

Why LangBot?

LangBot is an open-source, production-grade IM bot platform. Unlike simple scripts or single-platform bots, LangBot gives you:

Unified Platform: Connect once, deploy to WeChat, Discord, Telegram, Slack, Lark, and more.
Model Agnostic: Use DeepSeek R1, V3, Claude 3.5, GPT-4, or local Ollama models.
No Coding: robust WebUI for configuration.
Enterprise Features: Knowledge base (RAG), Plugin system, and multi-user management.

Prerequisites

A Server or PC: Docker installed (VPS, local computer, or Synology/NAS).
DeepSeek API Key:
- Official: platform.deepseek.com
- SiliconFlow (Recommended for speed): cloud.siliconflow.cn (Faster R1 inference).

Step 1: Deploy LangBot

If you haven't deployed LangBot yet, run this one command:

git clone https://github.com/langbot-app/LangBot
cd LangBot/docker
docker compose up -d

Access your dashboard at http://localhost:5300 (or your server IP).

Step 2: Configure DeepSeek Model

Go to Models -> Provider List.
Find DeepSeek (or SiliconFlow / OpenAI Compatible).
Enter your API Key.
Click Save.

Now create a Model Instance:

Name: DeepSeek-R1-Bot
Model: deepseek-reasoner (for R1) or deepseek-chat (for V3).

Step 3: Create a Chat Pipeline

LangBot uses "Pipelines" to manage bot logic.

Go to Pipelines -> New Pipeline.
Choose Chat Pipeline.
Select your DeepSeek-R1-Bot model.
(Optional) Add a System Prompt: > "You are a helpful assistant powered by DeepSeek R1. You think deeply before answering."

Step 4: Connect to WeChat (or any platform)

For WeChat (Personal / Wechaty)

Note: Personal WeChat access relies on third-party libraries and carries some risk. For business use, we recommend Enterprise WeChat (WeCom).

Go to Bots -> New Bot.
Select WeChat.
Choose the GeweChat or Wechaty adapter (depending on your preference).
Click Save.
Scan the QR code that appears in the logs or UI.

For Discord / Telegram

Select Discord or Telegram.
Paste your Bot Token (from Discord Developer Portal or BotFather).
Click Save.

Step 5: Test It Out!

Open your chat app and send a message. You should see DeepSeek R1 "thinking" (if supported) and replying with high-quality reasoning.

Advanced: Using Search & Tools

DeepSeek is great, but DeepSeek with Internet Access is better.

In LangBot:

Go to Plugins.
Install Tavily Search or Google Search.
Add the plugin to your DeepSeek Pipeline.

Now your bot can search the web for real-time info before reasoning with DeepSeek R1!

Ready to build?
Star us on GitHub or Read the Docs.

Originally published on LangBot Blog. Star us on GitHub!

Deploy Your Own AI Bot to Discord, Telegram & WeChat in 5 Minutes

Rock — Sat, 28 Feb 2026 10:35:59 +0000

What if you could have GPT-5, Claude, DeepSeek, and Gemini all answering questions in your Discord server, Telegram group, and WeChat — at the same time?

No API wrangling. No weeks of development. Just one Docker command.

That's LangBot — and it just crossed 15,000 stars on GitHub.

The Problem Everyone Faces

You want an AI assistant in your team's chat. Maybe for customer support on Telegram. Maybe for a coding helper in Discord. Maybe for a knowledge base bot in your company's WeChat or Lark group.

But then reality hits:

Each platform has its own bot API, webhook format, and auth flow
You need to handle message queuing, session management, and error recovery
Switching LLM providers means rewriting your integration layer
Adding RAG or tool calling is yet another project

LangBot solves all of this with a single, unified platform.

What Makes LangBot Different

13+ Messaging Platforms, One Codebase

Deploy a single LangBot instance and connect it to:

Global: Discord, Telegram, Slack, LINE, WhatsApp
Asia: WeChat (Official Account), WeCom, QQ, Lark, DingTalk, Feishu, KOOK

Each platform gets its own adapter — you just fill in your bot token in the WebUI and you're live.

20+ LLM Models, Zero Lock-in

Through LangBot Space, you get instant access to 20 cloud models out of the box — no API keys to manage:

Claude (Opus 4.6, Sonnet 4.5, Haiku 4.5)
GPT (GPT-5.2, GPT-5-mini, GPT-4.1-mini)
Gemini (3 Pro, 2.5 Pro, 2.5 Flash)
DeepSeek (R1, V3)
Grok (4, 4.1)
Qwen (3 Max)

Or add your own providers — OpenAI-compatible endpoints, Ollama for local models, any provider you want.

Built-in Agent with Tool Calling

LangBot's Local Agent isn't just a chat wrapper — it's a full agent runtime:

Multi-round conversations with configurable memory
Function calling / tool use for LLM-driven actions
MCP (Model Context Protocol) support for connecting to 100+ pre-built tools
Knowledge base (RAG) with built-in vector search

Plugin Marketplace

37+ community plugins and growing — install with one click:

WebSearch — Let your bot search the web
AI Image Generator — Generate images from text
LinkAnaly — Auto-preview links in chat
ScheNotify — Schedule reminders with natural language
Google Search, Tavily Search, RAGFlow Retriever, and more

Deploy in 5 Minutes — For Real

Step 1: Run Docker Compose

git clone https://github.com/langbot-app/LangBot
cd LangBot/docker
docker compose up -d

That's it. LangBot is now running at http://localhost:5300.

Step 2: Initialize with LangBot Space

Open the WebUI and click "Initialize with Space". This connects your instance to LangBot Space, giving you:

20 cloud models ready to use (with free credits)
One-click plugin installation
Managed API keys

Step 3: Configure Your Pipeline

Go to Pipelines and edit the default ChatPipeline:

Select your model (e.g., deepseek-v3, gpt-5-mini, claude-sonnet-4-5)
Customize the system prompt
Optionally attach a knowledge base or enable tools

Step 4: Connect a Platform

Go to Bots → click + → choose your platform (Discord, Telegram, etc.) → enter your bot token.

Done. Your bot is live.

Step 5: Test It

Use the built-in Debug Chat to test your pipeline before going live:

Real Conversations, Real Value

Here's what it looks like when LangBot is running in a QQ group — users asking technical questions and getting instant, accurate answers:

And in private chat:

Architecture That Scales

LangBot is built for production:

Pipeline architecture — each bot binds to a pipeline; pipelines handle AI logic, triggers, safety controls, and output formatting
Cross-process plugin isolation — a bad plugin can't crash your bot
Multiple runner backends — use LangBot's Local Agent, or connect to Dify, n8n, Langflow, Coze for complex workflows
Database flexibility — SQLite for dev, PostgreSQL for production
Vector DB options — Chroma, Qdrant, Milvus, pgvector, SeekDB

Why 15,000+ Developers Choose LangBot

Feature	LangBot	Building from Scratch
Platforms	13+ ready	Weeks per platform
LLM Providers	20+ models	Manual integration
Agent Runtime	Built-in	Build your own
RAG	Native + external	Separate project
Plugin System	Marketplace	DIY
Deployment	`docker compose up`	Days of setup
WebUI	Included	Build your own

Get Started

GitHub: github.com/langbot-app/LangBot — give us a star!
Documentation: docs.langbot.app
Plugin Market: space.langbot.app

git clone https://github.com/langbot-app/LangBot
cd LangBot/docker
docker compose up -d

Your AI bot empire starts with one command.

Originally published on LangBot Blog. Star us on GitHub!

Finally Got My Dify Agent Working in Discord, Telegram and Slack

Rock — Thu, 11 Dec 2025 04:27:01 +0000

Want your Dify Agent to break free from the browser and chat directly in WeChat, QQ, or Telegram? Combine LangBot with Dify and you can set it up in under 10 minutes.

Why This Combo?

LangBot is the most powerful open-source multi-platform chatbot framework available. It supports major Chinese IMs (QQ, WeChat, Feishu, DingTalk) and international platforms (Telegram, Discord, Slack, LINE). Its core strength is connecting AI backends to messaging apps.

Dify is one of the hottest AI app development platforms, offering visual Agent orchestration, 50+ built-in tools, and RAG knowledge bases. Together, they let you build a multi-platform AI assistant fast.

Deploy LangBot

Three commands with uvx:

mkdir langbot-instance
cd langbot-instance
uvx langbot@latest

Visit http://127.0.0.1:5300 and register an admin account:

Create a Dify Agent

Log in to cloud.dify.ai and create a new app. Choose Agent type - unlike basic chat apps, Agents can reason autonomously and call tools for complex tasks.

Configure the Agent

In the orchestration interface, set up:

System Instructions - Define the Agent's role:

You are an intelligent assistant that helps users complete various tasks. You have the following capabilities:
1. Answer various user questions
2. Query weather information
3. Retrieve webpage content

Please always maintain a friendly and professional attitude. If you need to use tools to get information, proactively call the relevant tools.

Add Tools - Pick from Dify's 50+ built-in tools, like Weather and Web Scraper:

Select Model - Supports GPT, Claude, Gemini, DeepSeek, and other major LLMs.

Final configuration:

Get the API Key

Click "Publish", then go to "Access API" to create a key:

Save the API key and server address https://api.dify.ai/v1.

Connect Dify to LangBot

Back in LangBot, go to Pipelines > ChatPipeline > AI Capability:

Select Dify Service API as the Runner:

Enter the configuration:

Base URL: https://api.dify.ai/v1
API Key: The key you just created
App Type: Chat (including Chatflow)

Save and click "Debug Conversation" to test:

If the Agent responds correctly and calls tools, the integration is working.

Why This Architecture Rocks

Decoupled Design: Agent capabilities live in Dify, LangBot handles message routing - each does what it's best at
One Config, Multi-Platform: Same Agent serves QQ, WeChat, Telegram, and more simultaneously
Easy to Extend: Add RAG knowledge bases, Workflow orchestration, or more tools in Dify later

Next Steps

Configure messaging platforms in LangBot (QQ bot, WeChat personal account, etc.)
Add more tools in Dify (database queries, API calls)
Try Dify Chatflow for complex conversation flows

If you're using n8n, FastGPT, Coze, or Langflow, LangBot supports those too.

Resources

LangBot Docs | GitHub
Dify Docs | Cloud Platform

How I Built a Multi-Platform AI Bot with Langflow's Drag-and-Drop Workflows

Rock — Fri, 05 Dec 2025 13:51:57 +0000

Drive chatbots across QQ, WeChat, Telegram, Discord, and more using visual workflows - no coding required.

LangBot is an open-source instant messaging bot platform that connects AI workflow engines like Langflow, n8n, Dify, FastGPT, and Coze to platforms including WeChat, QQ, Feishu, DingTalk, Telegram, Discord, Slack, and LINE. This tutorial demonstrates how to use Langflow's visual workflows as LangBot's conversation engine.

Why This Approach Works

True Multi-Platform: One workflow powering 8+ messaging platforms simultaneously
Visual Orchestration: Drag-and-drop conversation design with conditional branches, multi-turn dialogs, and external API calls
Flexible AI Models: Support for OpenAI, Claude, Gemini, DeepSeek, and local models
Fully Open Source: Both LangBot and Langflow are open-source projects for free deployment and customization

Prerequisites

Python 3.10+
Docker (recommended for quick deployment)
OpenAI API Key or API keys for other LLM services

Step 1: Deploy LangBot

Launch with uvx in one command:

uvx langbot

First run auto-initializes and opens your browser to http://127.0.0.1:5300.

After registration, log in to access the dashboard:

Step 2: Deploy Langflow

Deploy quickly with Docker:

docker run -d --name langflow -p 7860:7860 langflowai/langflow:latest

Visit http://localhost:7860 to access Langflow:

Step 3: Create a Langflow Workflow

In Langflow, select the "Basic Prompting" template to get started quickly:

This template includes four basic components:

Chat Input: Receives user messages
Prompt: Sets system instructions
Language Model: Calls LLM to generate responses
Chat Output: Returns results

Configure Language Model

Click the Language Model component and configure:

Model Provider: Select OpenAI (or other compatible providers like SiliconFlow, New API)
Model Name: Select gpt-4o-mini or deepseek-chat
OpenAI API Key: Enter your API Key

Tip: You can use OpenAI-compatible API services like SiliconFlow or New API by simply modifying the Base URL.

Save the workflow after configuration.

Step 4: Get Langflow API Information

Generate API Key

In Langflow's upper right: Settings → API Keys, navigate to the API Keys page:

Click Create New Key:

Generate and save the API Key:

Format: sk-xxxxxxxxxxxxxxxxxxxxxxxx

Get Flow ID

Extract from the flow editor's URL:

http://localhost:7860/flow/{flow-id}

Record this flow-id.

Step 5: Configure Langflow in LangBot

Return to LangBot dashboard and go to Pipelines page.

Click ChatPipeline to edit, in the AI tab:

Configure Runner, select Langflow API:

Fill in the Langflow configuration:

Configuration items:

Base URL: http://localhost:7860 (local) or http://langflow:7860 (Docker network)
API Key: The API Key generated in Langflow
Flow ID: The Flow ID recorded earlier

Docker Tip: If both services run in containers, ensure they're on the same network and use the container name for Base URL.

Click Save to save the configuration.

Step 6: Test the Conversation

Click Debug Chat on the Pipelines page to open the debug chat interface:

Enter a test message like "Hello" and view the AI response:

How It Works

User sends a message on a messaging platform
LangBot receives and passes it to the Pipeline
Pipeline calls Langflow API
Langflow executes the workflow: receives input → adds prompt → calls LLM → returns result
LangBot sends the response back to the user

Common Issues

Cannot connect to Langflow?

Check Base URL. For Docker deployment, ensure containers are on the same network:

docker network create langbot_network
docker network connect langbot_network langflow
docker network connect langbot_network langbot

Use container name: http://langflow:7860

API call fails?

Confirm API Key and Flow ID are correct
Verify the Language Model in Langflow has a valid LLM API Key configured

Advanced Use Cases

Langflow's power lies in visually orchestrating complex AI workflows:

Multi-Turn Memory: Add Memory components for contextual understanding
Conditional Branches: Execute different logic based on user input
External API Integration: Connect databases, search engines, third-party services
Multi-Agent Collaboration: Multiple LLM models working together
RAG Applications: Integrate vector databases for knowledge base Q&A

All achievable through drag-and-drop without writing code.

Summary

With LangBot + Langflow, you can rapidly build powerful multi-platform AI chatbots. Langflow provides visual workflow orchestration, LangBot handles messaging platform integration - together they create a complete loop from workflow design to multi-platform deployment.

This approach is ideal for:

Scenarios requiring the same AI capabilities across multiple platforms
Teams wanting rapid iteration and testing of different conversation flows
Developers wanting to build complex AI applications without deep coding

Related Resources

This article is based on the latest version of LangBot. LangBot supports integration with Dify, n8n, FastGPT, Coze, and other AI platforms - choose the workflow engine that best fits your needs.

How I Built a Multi-Platform AI Bot with Langflow's Drag-and-Drop Workflows

Rock — Fri, 05 Dec 2025 13:51:57 +0000

Drive chatbots across QQ, WeChat, Telegram, Discord, and more using visual workflows - no coding required.

Why This Approach Works

True Multi-Platform: One workflow powering 8+ messaging platforms simultaneously
Visual Orchestration: Drag-and-drop conversation design with conditional branches, multi-turn dialogs, and external API calls
Flexible AI Models: Support for OpenAI, Claude, Gemini, DeepSeek, and local models
Fully Open Source: Both LangBot and Langflow are open-source projects for free deployment and customization

Prerequisites

Python 3.10+
Docker (recommended for quick deployment)
OpenAI API Key or API keys for other LLM services

Step 1: Deploy LangBot

Launch with uvx in one command:

uvx langbot

First run auto-initializes and opens your browser to http://127.0.0.1:5300.

After registration, log in to access the dashboard:

Step 2: Deploy Langflow

Deploy quickly with Docker:

docker run -d --name langflow -p 7860:7860 langflowai/langflow:latest

Visit http://localhost:7860 to access Langflow:

Step 3: Create a Langflow Workflow

In Langflow, select the "Basic Prompting" template to get started quickly:

This template includes four basic components:

Chat Input: Receives user messages
Prompt: Sets system instructions
Language Model: Calls LLM to generate responses
Chat Output: Returns results

Configure Language Model

Click the Language Model component and configure:

Model Provider: Select OpenAI (or other compatible providers like SiliconFlow, New API)
Model Name: Select gpt-4o-mini or deepseek-chat
OpenAI API Key: Enter your API Key

Tip: You can use OpenAI-compatible API services like SiliconFlow or New API by simply modifying the Base URL.

Save the workflow after configuration.

Step 4: Get Langflow API Information

Generate API Key

In Langflow's upper right: Settings → API Keys, navigate to the API Keys page:

Click Create New Key:

Generate and save the API Key:

Format: sk-xxxxxxxxxxxxxxxxxxxxxxxx

Get Flow ID

Extract from the flow editor's URL:

http://localhost:7860/flow/{flow-id}

Record this flow-id.

Step 5: Configure Langflow in LangBot

Return to LangBot dashboard and go to Pipelines page.

Click ChatPipeline to edit, in the AI tab:

Configure Runner, select Langflow API:

Fill in the Langflow configuration:

Configuration items:

Base URL: http://localhost:7860 (local) or http://langflow:7860 (Docker network)
API Key: The API Key generated in Langflow
Flow ID: The Flow ID recorded earlier

Docker Tip: If both services run in containers, ensure they're on the same network and use the container name for Base URL.

Click Save to save the configuration.

Step 6: Test the Conversation

Click Debug Chat on the Pipelines page to open the debug chat interface:

Enter a test message like "Hello" and view the AI response:

How It Works

User sends a message on a messaging platform
LangBot receives and passes it to the Pipeline
Pipeline calls Langflow API
Langflow executes the workflow: receives input → adds prompt → calls LLM → returns result
LangBot sends the response back to the user

Common Issues

Cannot connect to Langflow?

Check Base URL. For Docker deployment, ensure containers are on the same network:

docker network create langbot_network
docker network connect langbot_network langflow
docker network connect langbot_network langbot

Use container name: http://langflow:7860

API call fails?

Confirm API Key and Flow ID are correct
Verify the Language Model in Langflow has a valid LLM API Key configured

Advanced Use Cases

Langflow's power lies in visually orchestrating complex AI workflows:

Multi-Turn Memory: Add Memory components for contextual understanding
Conditional Branches: Execute different logic based on user input
External API Integration: Connect databases, search engines, third-party services
Multi-Agent Collaboration: Multiple LLM models working together
RAG Applications: Integrate vector databases for knowledge base Q&A

All achievable through drag-and-drop without writing code.

Summary

This approach is ideal for:

Scenarios requiring the same AI capabilities across multiple platforms
Teams wanting rapid iteration and testing of different conversation flows
Developers wanting to build complex AI applications without deep coding

Related Resources

This article is based on the latest version of LangBot. LangBot supports integration with Dify, n8n, FastGPT, Coze, and other AI platforms - choose the workflow engine that best fits your needs.

How I Connected Dify Chatflow to My Multi-Platform Bot in Minutes

Rock — Thu, 04 Dec 2025 12:14:08 +0000

LangBot is a multi-platform chatbot framework that supports QQ, WeChat, Discord, Telegram, Slack, LINE, DingTalk, and Lark. One of its most powerful features is the support for multiple AI runners, including workflow platforms like Dify, n8n, Langflow, and Coze, as well as direct integration with OpenAI, Claude, and other LLM services.

Dify is an open-source LLM application development platform with visual Chatflow functionality, allowing you to build intelligent conversational applications without coding. This guide shows you how to integrate Dify Chatflow into LangBot to give your bot powerful AI capabilities.

What You Need

A running LangBot instance
A Dify account (you can use cloud.dify.ai)

Step 1: Deploy LangBot

If you haven't deployed LangBot yet, quickly start it with Docker:

docker run -d \
  -p 5300:5300 \
  -v ./data:/app/data \
  --name langbot \
  rockchin/langbot:latest

Visit http://localhost:5300 to access the management interface.

Default credentials:

Email: admin@langbot.app
Password: Admin123456

Step 2: Create Dify Chatflow Application

Visit cloud.dify.ai and log in. On the Studio page, click "Create from Blank" to create a new application.

Select "Chatflow" type - a conversational application with workflow support. Enter an application name (e.g., "LangBot Demo Chatflow") and create it.

Step 3: Configure the Workflow

After creation, you'll see a visual workflow editor with three default nodes:

START: Receives user input
LLM: Processes conversation
ANSWER: Returns response

Click the LLM node and add a system prompt in the "System" section:

You are a helpful AI assistant integrated with LangBot. You can answer questions and help users with various tasks.

You can add more nodes as needed - knowledge base retrieval, external API calls, conditional logic, and more to build more powerful conversational capabilities.

Step 4: Get API Key

Click "Publish" in the top right corner to publish your application, then click "API Access" to enter the API access page.

Click "Create new Secret key" to create an API key. Copy the generated key (format: app-xxxxxxxxxxxxxxxxxxxxxxxx).

Note down:

API Server: https://api.dify.ai/v1
API Key: The key you just created

Step 5: Configure LangBot

Return to the LangBot management interface, go to the "Pipelines" page, and click "+" to create a new pipeline.

Enter pipeline information:

Name: Dify Chatflow Pipeline
Description: Pipeline using Dify Chatflow as the AI runner

Switch to the "AI" tab, select "Dify Service API" in the "Runner" dropdown, and configure parameters:

Base URL: https://api.dify.ai/v1
App Type: Chat (Important: Chatflow apps use Chat type, not Workflow)
API Key: Paste your API key

Click "Save" to save.

Step 6: Test It

In the pipeline edit dialog, click "Debug Chat" to enter the debug interface. Enter a test message (like "Hello! This is a test message.") and press Enter.

If configured correctly, you'll see a reply from Dify Chatflow, indicating successful integration.

Common Issues

Error: not_workflow_app
This is due to incorrect App Type configuration. Chatflow apps must use "Chat" type, not "Workflow" type.

Invalid API Key
Ensure the key format is correct (starts with app-), has been created and activated in Dify, and Base URL is set to https://api.dify.ai/v1.

Connection Timeout
Check network connectivity, Dify service accessibility, and firewall settings.

What's Next

Now you can bind this pipeline to your bot and let it process user messages through Dify Chatflow. In Dify, you can further:

Add knowledge bases for RAG (Retrieval Augmented Generation)
Integrate external tools and APIs
Use conditional nodes for complex logic
Add variable transformations and data processing

LangBot supports configuring multiple pipelines simultaneously, allowing you to configure different AI capabilities for different scenarios and platforms. It also supports other AI platforms like n8n, Langflow, FastGPT, Coze, as well as direct integration with OpenAI, Claude, Google Gemini, and other LLM services.

Related Resources

How I Built a Multi-Platform AI Chatbot with n8n and LangBot

Rock — Wed, 03 Dec 2025 05:08:59 +0000

Connecting n8n's visual workflow automation with LangBot's multi-platform bot framework creates a powerful, code-free way to deploy AI chatbots across QQ, WeChat, Discord, Telegram, Slack, and more. This tutorial shows you how to integrate these tools in minutes.

What You'll Need

Python 3.8+ installed
Node.js 18+ installed
npm or npx available
15 minutes of your time

Deploy LangBot in 3 Commands

LangBot is a production-ready bot framework that connects to multiple messaging platforms and AI services including Dify, FastGPT, Coze, OpenAI, Claude, and Gemini. Deploy it instantly:

cd your-workspace
mkdir -p langbot-instance && cd langbot-instance
uvx langbot@latest

On first launch, LangBot initializes automatically. Open http://127.0.0.1:5300 in your browser.

Register your admin account when prompted. You'll land on the dashboard where you can manage bots, models, pipelines, and integrations.

Set Up n8n Workflow Automation

n8n is an open-source automation platform with 400+ integrations and powerful AI capabilities. Launch it locally:

cd your-workspace
mkdir -p n8n-data
export N8N_USER_FOLDER=$(pwd)/n8n-data
npx n8n

Visit http://127.0.0.1:5678 and create your owner account.

Build Your AI Workflow

Create a new workflow in n8n. You'll need two essential nodes:

Add the Webhook Trigger

Click "+" on the canvas and add a Webhook node. Configure it:

HTTP Method: POST
Response Mode: Streaming (enables real-time chat responses)
Authentication: None (adjust for production)

Add the AI Agent

Press Tab, navigate to the "AI" category, and select AI Agent.

Configure the Chat Model: Click "Chat Model" and choose "OpenAI Chat Model". Add your credentials:

API Key: Your OpenAI API key (or compatible service key)
Base URL: For OpenAI alternatives like Claude, Gemini, or local models, update to your provider's endpoint

Critical Step - Fix the Prompt Source: By default, the AI Agent expects a Chat Trigger node, which won't work with webhooks. Here's how to fix it:

Find "Source for Prompt (User Message)" in the AI Agent settings
Change from "Connected Chat Trigger Node" to "Define below"
Switch to "Expression" mode
Enter: {{ $json.body }}

This expression pulls the user's message from the webhook request body.

Activate and Get Your Webhook URL

Save the workflow and toggle the activation switch (top-right). Switch to the "Production URL" tab and copy the webhook URL:

http://localhost:5678/webhook/{your-webhook-id}

Connect LangBot to n8n

Back in the LangBot dashboard, navigate to Pipelines and click the default "ChatPipeline".

Switch to the AI tab and select "n8n Workflow API" from the Runner dropdown. Configure:

Webhook URL: Paste your n8n production webhook URL
Authentication Type: None (match your n8n webhook settings)
Timeout: 120 seconds
Output Key: response

Click Save.

Test It Out

In the Pipeline editor, click "Debug Chat" on the left sidebar. Send a test message like "What is LangBot?"

If everything works, you'll see LangBot send the message to n8n, where the AI Agent processes it and streams back a response.

Troubleshooting

Error: "Expected to find the prompt in an input field called 'chatInput'"

This means the AI Agent is still configured for a Chat Trigger node. Fix it:

Open the AI Agent configuration
Set "Source for Prompt (User Message)" to "Define below"
Switch to Expression mode
Enter: {{ $json.body }}

Test Your Webhook Directly

Verify the webhook works with curl:

curl -X POST http://localhost:5678/webhook/your-webhook-id \
  -H "Content-Type: application/json" \
  -d '{"body": "Hello, can you introduce yourself?"}'

You should receive streaming JSON with the AI's response.

How the Integration Works

Here's the complete flow:

User sends a message via QQ, WeChat, Discord, Telegram, Slack, LINE, or any LangBot-supported platform
LangBot's Pipeline receives the message and calls the n8n Workflow API
n8n's Webhook node captures the request and passes it to the AI Agent
The AI Agent uses OpenAI, Claude, Gemini, or your configured LLM to generate a response
n8n streams the response back to LangBot
LangBot delivers the response to the user on their original platform

Why This Combination Works

LangBot + n8n unlocks powerful capabilities:

No-Code AI Logic: Design conversation flows visually in n8n without touching code
Multi-Platform Reach: Deploy the same AI across QQ, WeChat, Discord, Telegram, Slack, LINE, DingTalk, and Lark simultaneously
Flexible AI Models: Swap between OpenAI GPT, Anthropic Claude, Google Gemini, Coze, Dify, local models, and more
Rich Integrations: Connect n8n's 400+ integrations - databases, APIs, Notion, Airtable, Google Sheets, Slack, and beyond
Tool-Calling Agents: AI Agent can trigger n8n tools like database queries, API calls, or custom functions
Workflow Extensions: Add preprocessing, content moderation, logging, or custom business logic

Perfect For:

Enterprise customer support bots
Knowledge base Q&A systems
Multi-platform community management
Task automation assistants
Unified chat interfaces for teams

Next Steps

Extend your bot further:

Integrate Dify or FastGPT for advanced RAG (retrieval-augmented generation)
Add vector database nodes (Pinecone, Qdrant, Weaviate) for knowledge retrieval
Connect business APIs for real-time data
Implement conversation memory and context tracking
Add content filtering and moderation workflows
Use Langflow or Coze for additional AI orchestration

This integration gives you the flexibility of code-based AI frameworks like LangChain with the simplicity of visual workflow builders - all while reaching users across every major messaging platform.

Ready to deploy your multi-platform AI assistant? Start with LangBot and n8n today.

LangBot 4.6.0 External Knowledge Base Tutorial: Integrating Dify with LangBot for RAG-powered Conversations

Rock — Tue, 02 Dec 2025 12:50:38 +0000

LangBot 4.6.0 introduces external knowledge base functionality, allowing users to integrate external knowledge retrieval services such as Dify and RAGFlow into conversation pipelines. This tutorial demonstrates how to combine Dify knowledge base with LangBot to enable intelligent conversations based on domain-specific knowledge.

Feature Overview

The external knowledge base feature enables LangBot to:

Connect to various external knowledge retrieval services (Dify, RAGFlow, etc.)
Provide professional answers based on domain-specific knowledge
Flexibly extend knowledge retrieval capabilities through the plugin system
Configure conveniently through WebUI without manual configuration file editing

Prerequisites

Before starting, you need:

Deploy LangBot 4.6.0 or higher
Have a Dify account (register at https://cloud.dify.ai)
Configure a conversation model (this tutorial uses claude-opus-4-1-20250805)

Step 1: Deploy LangBot

1.1 View LangBot Repository

First, visit the LangBot GitHub repository to understand the project. LangBot is a production-grade instant messaging bot development platform supporting multiple messaging platforms and LLM services.

1.2 Learn About External Knowledge Base Feature

Visit the official LangBot documentation to view the external knowledge base usage instructions. The documentation provides detailed explanations on how to build built-in knowledge bases and connect to external knowledge bases.

1.3 Start LangBot

Use the uvx langbot command to quickly start LangBot, then visit http://127.0.0.1:5300 for initialization. Fill in your email and password to complete registration, then log in.

1.4 Dashboard After Login

After successfully logging in, you will see the LangBot WebUI dashboard.

Step 2: Configure Conversation Model

Before using the knowledge base, you need to configure a conversation model.

2.1 Navigate to Model Configuration Page

Click "Models" in the left navigation bar to enter the model configuration page.

2.2 Add New Model

Click the "+" button to open the model configuration dialog.

2.3 Fill in Model Information

Fill in the following information:

Model Name: claude-opus-4-1-20250805
Model Provider: New API
Request URL: Your API endpoint
API Key: Your API Key
Abilities: Check Vision Ability and Function Call

Click "Submit" to save the configuration.

Step 3: Create Knowledge Base in Dify

3.1 Log in to Dify Platform

Visit https://cloud.dify.ai and log in to your account.

3.2 Navigate to Knowledge Page

Click "Knowledge" in the top navigation bar to enter the knowledge base management page.

3.3 Create New Knowledge Base

Click "Create Knowledge" to start creating a knowledge base.

3.4 Select Data Source

You can choose from the following methods to import data:

Import from file: Upload document files
Sync from Notion: Sync from Notion
Sync from website: Crawl website content

This tutorial selects "Import from file" and uploads prepared LangBot documentation.

3.5 Upload Document

After uploading the document, the system will display file information. Click "Next" to proceed.

3.6 Configure Document Processing Parameters

On the document processing page, you can configure chunk settings, index method, and retrieval settings:

Chunk Settings: General mode, maximum chunk length 1024 characters
Index Method: High Quality (uses embedding model)
Retrieval Setting: Vector Search

Click "Save & Process" to start processing the document.

3.7 Knowledge Base Processing

The system starts processing the document and generating vector embeddings.

3.8 Embedding Completed

After processing is complete, the knowledge base is ready to use.

Step 4: Get Dify API Information

4.1 Open Service API Panel

Click the "Service API" button in the bottom right. Record the following information:

Service API Endpoint: https://api.dify.ai/v1
Dataset ID: Get from the URL

4.2 Get API Key

Click the "API Key" button to view the API key. Record your API Key for use in subsequent configuration.

Step 5: Configure External Knowledge Base in LangBot

5.1 Navigate to Knowledge Page

In the LangBot WebUI, click "Knowledge" in the left navigation bar.

5.2 Switch to External Knowledge Base Tab

Click the "External" tab.

5.3 Add External Knowledge Base

Click the "+" button to open the add external knowledge base dialog. In this dialog, you need to:

Knowledge Base Name: Give the knowledge base a name
Knowledge Base Description: Add a description (optional)
Retriever: Select a knowledge retriever plugin

Note: Using an external knowledge base requires installing the corresponding knowledge retriever plugin first. You can search for and install the Dify knowledge retriever plugin in the plugin marketplace.

After installing the plugin, select the corresponding plugin from the Retriever dropdown, then fill in the configuration information obtained from Dify (API Endpoint, API Key, Dataset ID).

Step 6: Configure Pipeline

After configuring the external knowledge base, you need to enable it in the pipeline:

Navigate to the "Pipelines" page
Edit or create a new pipeline
On the "AI Capabilities" page, select "Built-in Agent" as the runner
In the knowledge base selection, check the external knowledge base you just configured
Save the pipeline configuration

Step 7: Test the Effect

Test in the pipeline's "Conversation Testing" page, or bind the pipeline to a bot for actual conversation testing. When users ask questions, LangBot will automatically retrieve relevant content from the Dify knowledge base and generate answers combined with the retrieved knowledge.

Frequently Asked Questions

1. How to Install Knowledge Retriever Plugins?

Visit the LangBot plugin marketplace, search for "Knowledge Retriever" or "Dify", find the corresponding plugin and click install.

2. Which External Knowledge Retrieval Services Are Supported?

LangBot currently supports multiple external knowledge retrieval services through the plugin system, including:

Dify
RAGFlow
Other custom knowledge retrieval services

Specific supported services can be viewed in the plugin marketplace.

3. What's the Difference Between External and Built-in Knowledge Bases?

Built-in Knowledge Base: Data is stored locally in LangBot, with LangBot handling vectorization and retrieval
External Knowledge Base: Data is stored in external services (like Dify), with retrieval performed through API calls

The advantage of external knowledge bases is the ability to leverage the capabilities of professional LLMOps platforms, such as Dify's advanced document processing and multiple retrieval strategies.

4. Can Multiple Knowledge Bases Be Used Simultaneously?

Yes. In the pipeline configuration, you can check multiple knowledge bases (built-in or external) simultaneously, and LangBot will comprehensively utilize the content from these knowledge bases to generate answers.

Summary

Through this tutorial, you learned how to:

Create a knowledge base and upload documents on the Dify platform
Obtain Dify API key and related configuration information
Configure a conversation model in LangBot
Add an external knowledge base in LangBot
Configure pipelines to use external knowledge bases

The external knowledge base feature provides LangBot with more powerful and flexible knowledge management capabilities. Combined with professional LLMOps platforms like Dify, you can build more intelligent and professional conversational bots.