kaiyuan/chatgpt-on-wechat
1
0
Fork 0
mirror of https://github.com/zhayujie/chatgpt-on-wechat.git synced 2026-07-19 21:07:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

docs: init docs

Browse Source
This commit is contained in:
zhayujie
2026-02-27 12:10:16 +08:00
parent 3ddbdd713d
commit d891312032
31 changed files with 2348 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
docs/en/architecture.mdx Normal file
View File

@@ -0,0 +1,93 @@
---
title: Architecture
description: CowAgent 2.0 system architecture and core design
---
# Architecture
CowAgent 2.0 is a comprehensive upgrade from a simple chatbot to an AI super assistant, built on an Agent architecture with autonomous thinking, task planning, long-term memory, and skill extension capabilities.
## System Architecture
```
┌──────────────────────────────────────────────────────┐
│ Channels │
│ Web │ Feishu │ DingTalk │ WeCom │ WeChat MP │
└───────────────────────┬──────────────────────────────┘
│
┌───────────────────────▼──────────────────────────────┐
│ Agent Core │
│ ┌─────────────┐ ┌──────────┐ ┌───────────────────┐ │
│ │ Task Planner│ │ Memory │ │ Skills Engine │ │
│ └──────┬──────┘ └────┬─────┘ └────────┬──────────┘ │
│ │ │ │ │
│ ┌──────▼─────────────▼────────────────▼──────────┐ │
│ │ Tools │ │
│ │ File R/W │ Bash │ Browser │ Scheduler │ ... │ │
│ └────────────────────────────────────────────────┘ │
└───────────────────────┬──────────────────────────────┘
│
┌───────────────────────▼──────────────────────────────┐
│ Models │
│ OpenAI │ Claude │ Gemini │ MiniMax │ GLM │ ... │
└──────────────────────────────────────────────────────┘
```
### Core Modules
| Module | Description |
| --- | --- |
| **Channels** | Message channel layer for receiving and sending messages, supporting Web, Feishu, DingTalk, WeCom, WeChat Official Accounts, etc. |
| **Agent Core** | The intelligent agent engine, including task planning, memory system, and skills engine |
| **Tools** | Tool layer through which the Agent accesses OS resources, with 10+ built-in tools |
| **Models** | Model layer supporting unified access to major domestic and international LLMs |
## Agent Mode
When Agent mode is enabled, CowAgent operates as an autonomous intelligent agent with the following workflow:
1. **Receive Message** - Receives user input through a channel
2. **Understand Intent** - Analyzes task requirements and context
3. **Plan Task** - Breaks complex tasks into multiple steps
4. **Call Tools** - Selects appropriate tools to execute each step
5. **Update Memory** - Stores important information in long-term memory
6. **Return Result** - Sends execution results back to the user
## Workspace
The Agent workspace defaults to `~/cow`, storing system prompts, memory files, skill files, etc.:
```
~/cow/
├── system.md # Agent system prompt
├── user.md # User profile
├── memory/ # Long-term memory storage
│ ├── core.md # Core memory
│ └── daily/ # Daily memory
├── skills/ # Custom skills
│ ├── skill-1/
│ └── skill-2/
└── .env # Secret keys for skills
```
## Core Configuration
Configure Agent mode parameters in `config.json`:
```json
{
"agent": true,
"agent_workspace": "~/cow",
"agent_max_context_tokens": 40000,
"agent_max_context_turns": 30,
"agent_max_steps": 15
}
```
| Parameter | Description | Default |
| --- | --- | --- |
| `agent` | Enable Agent mode | `true` |
| `agent_workspace` | Workspace path | `~/cow` |
| `agent_max_context_tokens` | Maximum context tokens | `40000` |
| `agent_max_context_turns` | Maximum context conversation turns | `30` |
| `agent_max_steps` | Maximum tool call steps per task | `15` |

40
docs/en/channels/dingtalk.mdx Normal file
View File

@@ -0,0 +1,40 @@
---
title: DingTalk
description: Integrate CowAgent with DingTalk
---
# DingTalk
Create a smart bot application on the DingTalk Open Platform to integrate CowAgent.
## 1. Create an App
1. Go to [DingTalk Developer Console](https://open-dev.dingtalk.com/fe/app#/corp/app), click **Create App**, and fill in the information
2. Add the **Bot** capability
3. Configure bot info and click **Publish**
## 2. Project Configuration
1. Get `Client ID` and `Client Secret` from **Credentials & Basic Info**
2. Add to `config.json`:
```json
{
"channel_type": "dingtalk",
"dingtalk_client_id": "YOUR_CLIENT_ID",
"dingtalk_client_secret": "YOUR_CLIENT_SECRET"
}
```
3. Install dependency:
```bash
pip3 install dingtalk_stream
```
4. After starting the project, go to **Event Subscription** in the DingTalk console, click **Verify Connection** — it should show "Connection successful"
## 3. Usage
Chat with the bot privately or add it to a group chat to start a conversation.

69
docs/en/channels/feishu.mdx Normal file
View File

@@ -0,0 +1,69 @@
---
title: Feishu (Lark)
description: Integrate CowAgent with Feishu
---
# Feishu (Lark)
Integrate CowAgent into Feishu by creating a custom app. Supports WebSocket (recommended) and Webhook event modes.
## 1. Create a Custom App
### Create the App
Go to [Feishu Open Platform](https://open.feishu.cn/app/), click **Create Custom App**, and fill in the required information.
### Add Bot Capability
In the **Add App Capabilities** menu, add the **Bot** capability.
### Configure Permissions
Go to **Permission Management**, paste the following permissions, select all, and enable them:
```
im:message,im:message.group_at_msg,im:message.group_at_msg:readonly,im:message.p2p_msg,im:message.p2p_msg:readonly,im:message:send_as_bot,im:resource
```
## 2. Project Configuration
Get `App ID` and `App Secret` from **Credentials & Basic Info**, then add to `config.json`:
<Tabs>
<Tab title="WebSocket (Recommended)">
No public IP required:
```json
{
"channel_type": "feishu",
"feishu_app_id": "YOUR_APP_ID",
"feishu_app_secret": "YOUR_APP_SECRET",
"feishu_event_mode": "websocket"
}
```
Install dependency: `pip3 install lark-oapi`
</Tab>
<Tab title="Webhook">
Requires public IP:
```json
{
"channel_type": "feishu",
"feishu_app_id": "YOUR_APP_ID",
"feishu_app_secret": "YOUR_APP_SECRET",
"feishu_token": "VERIFICATION_TOKEN",
"feishu_event_mode": "webhook",
"feishu_port": 9891
}
```
</Tab>
</Tabs>
## 3. Configure Event Subscription
1. After starting the project, go to **Events & Callbacks** on the Feishu Open Platform, select **Long Connection** mode, and save
2. Click **Add Event**, search for "Receive Message", select "Receive Message v2.0", and confirm
3. Go to **Version Management & Release**, create a new version, and submit for release approval
Once approved, search for the bot name in Feishu to start chatting.

33
docs/en/channels/web.mdx Normal file
View File

@@ -0,0 +1,33 @@
---
title: Web
description: Use CowAgent through the Web interface
---
# Web
Web is the default channel for CowAgent. A Web console starts automatically on launch, allowing you to chat with the Agent through your browser.
## Configuration
```json
{
"channel_type": "web",
"web_port": 9899
}
```
| Parameter | Description | Default |
| --- | --- | --- |
| `channel_type` | Set to `web` | `web` |
| `web_port` | Web service listening port | `9899` |
## Usage
After starting the project, visit:
- Local: `http://localhost:9899/chat`
- Server: `http://<server-ip>:9899/chat`
<Note>
Ensure your server firewall and security group allow access to the configured port.
</Note>

58
docs/en/channels/wechatmp.mdx Normal file
View File

@@ -0,0 +1,58 @@
---
title: WeChat Official Account
description: Integrate CowAgent with WeChat Official Accounts
---
# WeChat Official Account
CowAgent supports both personal subscription accounts and enterprise service accounts.
| Type | Requirements | Features |
| --- | --- | --- |
| **Personal Subscription** | Available to individuals | Users must send a message to retrieve replies |
| **Enterprise Service** | Enterprise registration with verified customer service API | Can proactively push replies to users |
<Note>
Official Accounts only support server and Docker deployment. Install extended dependencies: `pip3 install -r requirements-optional.txt`
</Note>
## Personal Subscription Account
Add the following to `config.json`:
```json
{
"channel_type": "wechatmp",
"wechatmp_app_id": "YOUR_APP_ID",
"wechatmp_app_secret": "YOUR_APP_SECRET",
"wechatmp_aes_key": "",
"wechatmp_token": "YOUR_TOKEN",
"wechatmp_port": 80
}
```
### Setup Steps
1. Get parameters from [WeChat Official Account Platform](https://mp.weixin.qq.com/) under **Settings & Development → Basic Configuration → Server Configuration**
2. Enable developer secret and add server IP to the whitelist
3. Start the program (listens on port 80)
4. In the official account console, **enable server configuration** with URL format `http://{HOST}/wx`
## Enterprise Service Account
The setup is largely identical to the subscription account, with these differences:
1. Register an enterprise service account and complete WeChat verification, ensure **Customer Service API** permission is granted
2. Set `"channel_type": "wechatmp_service"` in `config.json`
3. Replies can be proactively pushed to users without them having to manually retrieve them
```json
{
"channel_type": "wechatmp_service",
"wechatmp_app_id": "YOUR_APP_ID",
"wechatmp_app_secret": "YOUR_APP_SECRET",
"wechatmp_aes_key": "",
"wechatmp_token": "YOUR_TOKEN",
"wechatmp_port": 80
}
```

59
docs/en/channels/wecom.mdx Normal file
View File

@@ -0,0 +1,59 @@
---
title: WeCom
description: Integrate CowAgent with WeCom (WeChat Work) custom app
---
# WeCom (WeChat Work)
Integrate CowAgent through a WeCom custom application for internal team messaging.
<Note>
WeCom only supports Docker deployment or server-based Python deployment, not local running mode.
</Note>
## 1. Prerequisites
- A server with a public IP
- A WeCom account (individuals can register but cannot be verified)
- For verified WeCom accounts, a domain registered to the same entity
## 2. Create a WeCom App
1. In the [WeCom Admin Console](https://work.weixin.qq.com/wework_admin/frame#profile), go to **My Enterprise** to get the **Corp ID**
2. Go to **App Management**, create a new app, and note the `AgentId` and `Secret`
3. Click **Set API Receive**, configure the app interface:
- URL format: `http://ip:port/wxcomapp` (verified enterprises need a registered domain)
- Generate and save the `Token` and `EncodingAESKey`
## 3. Configuration and Startup
```json
{
"channel_type": "wechatcom_app",
"wechatcom_corp_id": "YOUR_CORP_ID",
"wechatcomapp_token": "YOUR_TOKEN",
"wechatcomapp_secret": "YOUR_SECRET",
"wechatcomapp_agent_id": "YOUR_AGENT_ID",
"wechatcomapp_aes_key": "YOUR_AES_KEY",
"wechatcomapp_port": 9898
}
```
| Parameter | Description |
| --- | --- |
| `wechatcom_corp_id` | Enterprise Corp ID |
| `wechatcomapp_token` | Token from API receive config |
| `wechatcomapp_secret` | App Secret |
| `wechatcomapp_agent_id` | App AgentId |
| `wechatcomapp_aes_key` | EncodingAESKey from API receive config |
| `wechatcomapp_port` | Listening port, default 9898 |
After starting the program, save the **message server configuration** in the WeCom console, then add the server IP to **Trusted IPs**.
<Warning>
If configuration fails: 1. Ensure the firewall and security group allow the port; 2. Verify all parameters match; 3. Verified enterprises need a registered domain.
</Warning>
## 4. Usage
Search for the app name in WeCom to start chatting. To allow external WeChat users, share the invitation QR code from **My Enterprise → WeChat Plugin**.

101
docs/en/configuration.mdx Normal file
View File

@@ -0,0 +1,101 @@
---
title: Configuration
description: CowAgent configuration file reference
---
# Configuration
The config template is located at `config-template.json` in the project root. Copy it to create the active `config.json`:
```bash
cp config-template.json config.json
```
## Core Settings
```json
{
"channel_type": "web",
"model": "MiniMax-M2.5",
"agent": true,
"agent_workspace": "~/cow",
"agent_max_context_tokens": 40000,
"agent_max_context_turns": 30,
"agent_max_steps": 15
}
```
| Parameter | Description | Default |
| --- | --- | --- |
| `channel_type` | Channel type | `web` |
| `model` | Model name | `MiniMax-M2.5` |
| `agent` | Enable Agent mode | `true` |
| `agent_workspace` | Agent workspace path | `~/cow` |
| `agent_max_context_tokens` | Maximum context tokens | `40000` |
| `agent_max_context_turns` | Maximum context conversation turns | `30` |
| `agent_max_steps` | Maximum tool call steps per task | `15` |
## Model API Keys
Fill in the API key for your chosen model:
```json
{
"minimax_api_key": "",
"zhipu_ai_api_key": "",
"moonshot_api_key": "",
"ark_api_key": "",
"dashscope_api_key": "",
"claude_api_key": "",
"gemini_api_key": "",
"open_ai_api_key": ""
}
```
See [Models](/en/models) for detailed model configuration.
## Voice Settings
```json
{
"speech_recognition": false,
"group_speech_recognition": false,
"voice_reply_voice": false
}
```
| Parameter | Description |
| --- | --- |
| `speech_recognition` | Enable private chat voice recognition |
| `group_speech_recognition` | Enable group chat voice recognition |
| `voice_reply_voice` | Reply to voice messages with voice |
## LinkAI Settings
```json
{
"use_linkai": false,
"linkai_api_key": "",
"linkai_app_code": ""
}
```
| Parameter | Description |
| --- | --- |
| `use_linkai` | Enable LinkAI integration |
| `linkai_api_key` | LinkAI API Key, create at [console](https://link-ai.tech/console/interface) |
| `linkai_app_code` | LinkAI app or workflow code |
## Proxy Settings
If you need a network proxy:
```json
{
"proxy": "127.0.0.1:7890"
}
```
<Tip>
For all configuration options, see the [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py) file in the project.
</Tip>

64
docs/en/index.mdx Normal file
View File

@@ -0,0 +1,64 @@
---
title: Introduction
description: CowAgent - AI Super Assistant powered by LLMs
---
# CowAgent
**CowAgent** is an AI super assistant powered by large language models, capable of autonomous thinking and task planning, operating computers and external resources, creating and executing Skills, with long-term memory that grows with you.
CowAgent supports flexible switching between multiple models, handles multimodal messages including text, voice, images, and files, and can be integrated into web, Feishu (Lark), DingTalk, WeCom, and WeChat Official Accounts for 24/7 operation on your personal computer or server.
## Core Capabilities
<CardGroup cols={2}>
<Card title="Complex Task Planning" icon="brain">
Understands complex tasks and autonomously plans execution, continuously thinking and calling tools until the goal is achieved. Supports accessing files, terminals, browsers, scheduled tasks, and other system resources.
</Card>
<Card title="Long-term Memory" icon="database">
Automatically persists conversation memory to local files and databases, including core memory and daily memory, with keyword and vector search support.
</Card>
<Card title="Skills System" icon="puzzle-piece">
Implements a Skills creation and execution engine with multiple built-in skills, and supports custom skill development through natural language conversations.
</Card>
<Card title="Multimodal Messages" icon="image">
Supports parsing, processing, generating, and sending multiple message types including text, images, voice, and files.
</Card>
<Card title="Multiple Models" icon="microchip">
Supports OpenAI, Claude, Gemini, DeepSeek, MiniMax, GLM, Qwen, Kimi, Doubao, and other major model providers.
</Card>
<Card title="Multi-platform Deployment" icon="server">
Runs on local computers or servers, integrable with web, Feishu, DingTalk, WeChat Official Accounts, and WeCom.
</Card>
</CardGroup>
## Quick Experience
Run the following command in your terminal to install, configure, and start CowAgent with one click:
```bash
bash <(curl -sS https://cdn.link-ai.tech/code/cow/run.sh)
```
After running, a Web service starts by default. Visit `http://localhost:9899/chat` to start chatting.
<CardGroup cols={2}>
<Card title="Quick Start" icon="rocket" href="/en/quick-start">
View the complete installation and setup guide
</Card>
<Card title="Architecture" icon="sitemap" href="/en/architecture">
Learn about the CowAgent system architecture
</Card>
</CardGroup>
## Disclaimer
1. This project follows the [MIT License](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/LICENSE) and is primarily for technical research and learning.
2. Token usage in Agent mode is higher than regular chat mode. Please choose models based on both effectiveness and cost. The Agent has access to the operating system — please choose deployment environments carefully.
3. The CowAgent project focuses on open-source technology development and will not participate in, authorize, or issue any cryptocurrency.
## Community
Join the open-source community by adding the assistant on WeChat:
<img width="140" src="https://img-1317903499.cos.ap-guangzhou.myqcloud.com/docs/open-community.png" />

68
docs/en/memory.mdx Normal file
View File

@@ -0,0 +1,68 @@
---
title: Memory
description: CowAgent long-term memory system
---
# Long-term Memory
The memory system enables the Agent to remember important information over time, continuously accumulating experience, understanding user preferences, and achieving autonomous thinking and growth.
## How It Works
The Agent proactively stores memory in these scenarios:
- **When users share important information** — Automatically identifies and stores preferences, decisions, facts, and other key information
- **When conversations reach a certain length** — Automatically extracts summaries to prevent information loss
- **When retrieval is needed** — Intelligently searches historical memory and combines it with context
## Memory Types
### Core Memory
Stored in `~/cow/memory/core.md`, containing long-term user preferences, important decisions, key facts, and other information that doesn't fade over time.
### Daily Memory
Stored in the `~/cow/memory/daily/` directory, organized by date, recording daily conversation summaries and key events.
## First Startup
On first startup, the Agent proactively asks the user for key information and records it in the workspace (default `~/cow`):
| File | Description |
| --- | --- |
| `system.md` | Agent system prompt and behavior settings |
| `user.md` | User identity and preferences |
| `memory/core.md` | Core memory |
| `memory/daily/` | Daily memory directory |
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
</Frame>
## Memory Retrieval
The memory system supports hybrid retrieval:
- **Keyword Search** — Matches historical memory based on keywords
- **Vector Search** — Semantic similarity search that finds related memories even with different wording
The Agent automatically triggers memory retrieval during conversations, incorporating relevant historical information into the context.
## Configuration
Adjust memory-related parameters in `config.json`:
```json
{
"agent_workspace": "~/cow",
"agent_max_context_tokens": 40000,
"agent_max_context_turns": 30
}
```
| Parameter | Description | Default |
| --- | --- | --- |
| `agent_workspace` | Workspace path where memory files are stored | `~/cow` |
| `agent_max_context_tokens` | Maximum context tokens, affects short-term memory capacity | `40000` |
| `agent_max_context_turns` | Maximum context turns, older conversations are discarded when exceeded | `30` |

173
docs/en/models.mdx Normal file
View File

@@ -0,0 +1,173 @@
---
title: Models
description: Supported models and configuration guide
---
# Models
CowAgent supports major LLM providers from China and worldwide. Model implementations are in the `models/` directory.
<Note>
Recommended models for Agent mode: MiniMax-M2.5, glm-5, kimi-k2.5, qwen3.5-plus, claude-sonnet-4-6, gemini-3.1-pro-preview. Choose based on effectiveness and cost.
</Note>
## Model Configuration
Set the model name and corresponding API key in `config.json`.
### MiniMax
```json
{
"model": "MiniMax-M2.5",
"minimax_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `MiniMax-M2.5`, `MiniMax-M2.1`, `MiniMax-M2.1-lightning`, `MiniMax-M2`, etc. |
| `minimax_api_key` | Create at [MiniMax Console](https://platform.minimaxi.com/user-center/basic-information/interface-key) |
### GLM (Zhipu AI)
```json
{
"model": "glm-5",
"zhipu_ai_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `glm-5`, `glm-4.7`, `glm-4-plus`, `glm-4-flash`, etc. See [model list](https://bigmodel.cn/dev/api/normal-model/glm-4) |
| `zhipu_ai_api_key` | Create at [Zhipu AI Console](https://www.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
### Qwen (Tongyi Qianwen)
```json
{
"model": "qwen3.5-plus",
"dashscope_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `qwen3.5-plus`, `qwen3-max`, `qwen-max`, `qwen-plus`, etc. |
| `dashscope_api_key` | Create at [Bailian Console](https://bailian.console.aliyun.com/?tab=model#/api-key) |
### Kimi (Moonshot)
```json
{
"model": "kimi-k2.5",
"moonshot_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `kimi-k2.5`, `kimi-k2`, `moonshot-v1-8k`, `moonshot-v1-32k`, etc. |
| `moonshot_api_key` | Create at [Moonshot Console](https://platform.moonshot.cn/console/api-keys) |
### Doubao (ByteDance)
```json
{
"model": "doubao-seed-2-0-code-preview-260215",
"ark_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `doubao-seed-2-0-code-preview-260215`, `doubao-seed-2-0-pro-260215`, etc. |
| `ark_api_key` | Create at [Volcano Ark Console](https://console.volcengine.com/ark/region:ark+cn-beijing/apikey) |
### Claude
```json
{
"model": "claude-sonnet-4-6",
"claude_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `claude-sonnet-4-6`, `claude-opus-4-6`, `claude-sonnet-4-5`, etc. See [official models](https://docs.anthropic.com/en/docs/about-claude/models/overview) |
| `claude_api_key` | Create at [Claude Console](https://console.anthropic.com/settings/keys) |
| `claude_api_base` | Optional, defaults to `https://api.anthropic.com/v1` |
### Gemini
```json
{
"model": "gemini-3.1-pro-preview",
"gemini_api_key": "YOUR_API_KEY"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `gemini-3.1-pro-preview`, `gemini-3-flash-preview`, `gemini-2.5-pro`, etc. See [official docs](https://ai.google.dev/gemini-api/docs/models) |
| `gemini_api_key` | Create at [Google AI Studio](https://aistudio.google.com/app/apikey) |
### OpenAI
```json
{
"model": "gpt-4.1-mini",
"open_ai_api_key": "YOUR_API_KEY",
"open_ai_api_base": "https://api.openai.com/v1"
}
```
| Parameter | Description |
| --- | --- |
| `model` | o-series, gpt-5.2, gpt-4.1, etc. See [model list](https://platform.openai.com/docs/models) |
| `open_ai_api_key` | Create at [OpenAI Platform](https://platform.openai.com/api-keys) |
| `open_ai_api_base` | Optional, modify to use third-party proxy |
### DeepSeek
```json
{
"model": "deepseek-chat",
"open_ai_api_key": "YOUR_API_KEY",
"open_ai_api_base": "https://api.deepseek.com/v1",
"bot_type": "chatGPT"
}
```
| Parameter | Description |
| --- | --- |
| `model` | `deepseek-chat` (V3), `deepseek-reasoner` (R1) |
| `bot_type` | OpenAI-compatible mode, set to `chatGPT` |
## OpenAI-Compatible Access
Most models also support OpenAI-compatible access. Set `bot_type` to `chatGPT` and configure the corresponding `open_ai_api_base` and `open_ai_api_key`.
## LinkAI Platform
[LinkAI](https://link-ai.tech) allows flexible model switching with knowledge base, workflow, and plugin support.
```json
{
"use_linkai": true,
"linkai_api_key": "YOUR_API_KEY",
"linkai_app_code": "YOUR_APP_CODE"
}
```
| Parameter | Description |
| --- | --- |
| `use_linkai` | Set to `true` to enable LinkAI |
| `linkai_api_key` | Create at [console](https://link-ai.tech/console/interface) |
| `linkai_app_code` | LinkAI agent code, optional |
<Tip>
For all model names, see [`common/const.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/common/const.py) in the project.
</Tip>

120
docs/en/quick-start.mdx Normal file
View File

@@ -0,0 +1,120 @@
---
title: Quick Start
description: One-click install or manually deploy CowAgent
---
# Quick Start
CowAgent supports Linux, macOS, and Windows. It can run on personal computers or servers and requires Python 3.7 ~ 3.12 (3.9 recommended).
## One-click Install
The project provides a script for one-click installation, configuration, startup, and management:
```bash
bash <(curl -sS https://cdn.link-ai.tech/code/cow/run.sh)
```
The script automatically:
1. Checks the Python environment (requires Python 3.7+)
2. Installs necessary tools (git, curl, etc.)
3. Clones the project to `~/chatgpt-on-wechat`
4. Installs Python dependencies
5. Guides configuration of AI models and channels
6. Starts the service
### Management Commands
After installation, use the following commands to manage the service:
| Command | Description |
| --- | --- |
| `./run.sh start` | Start service |
| `./run.sh stop` | Stop service |
| `./run.sh restart` | Restart service |
| `./run.sh status` | Check status |
| `./run.sh logs` | View live logs |
| `./run.sh config` | Reconfigure |
| `./run.sh update` | Update project |
## Manual Installation
### 1. Clone the Repository
```bash
git clone https://github.com/zhayujie/chatgpt-on-wechat
cd chatgpt-on-wechat/
```
<Tip>
For users in China, use the mirror: https://gitee.com/zhayujie/chatgpt-on-wechat
</Tip>
### 2. Install Dependencies
Core dependencies (required):
```bash
pip3 install -r requirements.txt
```
Extended dependencies (optional, recommended):
```bash
pip3 install -r requirements-optional.txt
```
### 3. Configuration
Copy the config template and edit:
```bash
cp config-template.json config.json
```
See [Configuration](/en/configuration) for detailed settings.
### 4. Run
**Local:**
```bash
python3 app.py
```
After starting, visit `http://localhost:9899/chat` to begin chatting.
**Server (background):**
```bash
nohup python3 app.py & tail -f nohup.out
```
## Docker Deployment
Docker deployment requires no source code download or dependency installation. Source code deployment is recommended in Agent mode for better system access.
<Note>
Requires [Docker](https://docs.docker.com/engine/install/) and docker-compose.
</Note>
**1. Download config file**
```bash
wget https://cdn.link-ai.tech/code/cow/docker-compose.yml
```
Edit `docker-compose.yml` to fill in required configuration.
**2. Start container**
```bash
sudo docker compose up -d
```
**3. View logs**
```bash
sudo docker logs -f chatgpt-on-wechat
```

25
docs/en/releases/overview.mdx Normal file
View File

@@ -0,0 +1,25 @@
---
title: Changelog
description: CowAgent version history
---
# Changelog
| Version | Date | Description |
| --- | --- | --- |
| [2.0.0](/en/releases/v2.0.0) | 2026.02.03 | Full upgrade to AI super assistant |
| 1.7.6 | 2025.05.23 | Web Channel optimization, AgentMesh plugin |
| 1.7.5 | 2025.04.11 | wechatferry protocol, DeepSeek model |
| 1.7.4 | 2024.12.13 | Gemini 2.0 model, Web Channel |
| 1.7.3 | 2024.10.31 | Stability improvements, database features |
| 1.7.2 | 2024.09.26 | One-click install script, o1 model |
| 1.7.0 | 2024.08.02 | iFlytek 4.0 model, knowledge base references |
| 1.6.9 | 2024.07.19 | gpt-4o-mini, Alibaba voice recognition |
| 1.6.8 | 2024.07.05 | Claude 3.5, Gemini 1.5 Pro |
| 1.6.0 | 2024.04.26 | Kimi integration, gpt-4-turbo upgrade |
| 1.5.8 | 2024.03.26 | GLM-4, Claude-3, edge-tts |
| 1.5.2 | 2023.11.10 | Feishu channel, image recognition |
| 1.5.0 | 2023.11.10 | gpt-4-turbo, dall-e-3, tts multimodal |
| 1.0.0 | 2022.12.12 | Project created, first ChatGPT integration |
See [GitHub Releases](https://github.com/zhayujie/chatgpt-on-wechat/releases) for full history.

107
docs/en/releases/v2.0.0.mdx Normal file
View File

@@ -0,0 +1,107 @@
---
title: v2.0.0
description: CowAgent 2.0 - Full upgrade from chatbot to AI super assistant
---
# CowAgent 2.0
CowAgent 2.0 is a comprehensive upgrade from a chatbot to an **AI super assistant**! It can now autonomously think and plan tasks, has long-term memory, operates computers and external resources, and creates and executes skills — truly understanding you and growing alongside you.
**Release Date**: 2026.02.03 | [GitHub Release](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0)
## Key Updates
### Agent Core Capabilities
- **Complex Task Planning**: Understands complex tasks and autonomously plans execution, continuously thinking and calling tools until goals are achieved, with multi-turn reasoning and context understanding
- **Long-term Memory**: Automatically persists conversation memory to local files and databases, including core memory and daily memory, with keyword and vector search support
- **Built-in System Tools**: 10+ built-in tools including file operations, Bash terminal, browser, file sending, scheduled tasks, memory management, etc.
- **Skills**: New Skill execution engine with built-in skills and support for custom skill development through natural language conversation
- **Security and Cost**: Controls Agent access security through secret key management, prompt controls, and system permissions; limits token costs through max memory turns, max context tokens, and tool execution steps
### Other Updates
- **Channel Improvements**: Feishu and DingTalk channels support WebSocket connections (no public IP needed), with image/file message support
- **Model Updates**: Added claude-sonnet-4-5, gemini-3-pro-preview, glm-4.7, MiniMax-M2.1, qwen3-max, and other latest models
- **Deployment**: Added one-click install, configure, run, and management script to simplify deployment
## Long-term Memory System
The Agent proactively stores information when users share important details, and automatically extracts summaries when conversations reach a certain length. Supports hybrid retrieval with semantic search and vector search.
On **first startup**, the Agent proactively asks for key information and records it in the workspace (default `~/cow`) including agent settings, user identity, and memory files.
During **long-term conversations**, the Agent intelligently records and retrieves memories, continuously updating its settings, user preferences, and summarizing experiences — achieving true autonomous thinking and continuous growth.
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
</Frame>
## Task Planning and Tool Calling
The Agent intelligently selects and calls tools based on task requirements to complete various complex operations.
### Terminal and File Access
The most fundamental tool capabilities. Users can interact with the Agent from mobile devices to operate resources on personal computers or servers:
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202181130.png" width="800" />
</Frame>
### Application Programming
With programming and system access capabilities, the Agent can handle the complete **Vibecoding workflow** — from information search, asset generation, coding, testing, deployment, Nginx configuration, to publishing — all from a single mobile command.
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260203121008.png" width="800" />
</Frame>
### Scheduled Tasks
Supports **one-time tasks, fixed intervals, and Cron expressions**, with two trigger modes: **fixed message sending** or **Agent dynamic task execution**:
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202195402.png" width="800" />
</Frame>
### Environment Variable Management
Manages skill-required secrets via the `env_config` tool, with conversational updates and built-in security protection and data masking:
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202234939.png" width="800" />
</Frame>
## Skills System
Each Skill consists of a description file, execution script (optional), and resources (optional), providing infinite extensibility.
### Skill Creator
Quickly create skills through conversation, codifying workflows or integrating with any third-party API:
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
</Frame>
### Search and Image Recognition
- **Search Skill**: Built-in `bocha-search`, configure `BOCHA_SEARCH_API_KEY` to enable
- **Image Recognition**: Supports `gpt-4.1-mini`, `gpt-4.1`, etc., configure `OPENAI_API_KEY` to enable
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
</Frame>
### Third-party Knowledge Bases and Plugins
The `linkai-agent` skill integrates all agents from [LinkAI](https://link-ai.tech/) as Skills, enabling multi-agent decision-making:
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202234350.png" width="750" />
</Frame>
## Contributing
After version 2.0, the project will continue upgrading Agent capabilities, expanding channels, built-in tools, and the skills system, while reducing model costs and improving security. Welcome to [submit feedback](https://github.com/zhayujie/chatgpt-on-wechat/issues) and [contribute code](https://github.com/zhayujie/chatgpt-on-wechat/pulls).

103
docs/en/skills.mdx Normal file
View File

@@ -0,0 +1,103 @@
---
title: Skills
description: CowAgent Skills System - infinite extensibility for the Agent
---
# Skills System
The Skills system provides infinite extensibility for the Agent. Each Skill consists of a description file, an execution script (optional), and resources (optional), describing how to complete a specific type of task. Skills enable the Agent to follow instructions to complete complex workflows, call various tools, or integrate with third-party systems.
## Skill Types
### Built-in Skills
Located in the `skills/` directory of the project, automatically enabled based on dependency conditions (API keys, system commands, etc.).
| Skill | Description |
| --- | --- |
| `skill-creator` | Skill creator — create custom skills through conversation |
| `bocha-search` | Web search capability |
| `openai-image-vision` | Image recognition using OpenAI vision models |
| `linkai-agent` | LinkAI agent integration for third-party knowledge bases and plugins |
| `web-scraper` | Web page content extraction |
### Custom Skills
Created by users through conversation, stored in the workspace (`~/cow/skills/`). Custom skills can implement any complex business workflow or third-party system integration.
## Creating Skills
Use the built-in `skill-creator` to create skills through natural language conversation:
- Codify workflows into reusable skills
- Send API documentation and examples to the Agent for automatic integration
- Create customized automation pipelines
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
</Frame>
## Web Search
The built-in `bocha-search` skill provides web search capability:
1. Create an API Key at [Bocha Open Platform](https://open.bochaai.com/)
2. Configure `BOCHA_SEARCH_API_KEY` via the `env_config` tool or send it directly to the Agent
## Image Recognition
The `openai-image-vision` skill supports image recognition using models like `gpt-4.1-mini` and `gpt-4.1`.
Configure `OPENAI_API_KEY` via `config.json` or the `env_config` tool to enable.
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
</Frame>
## LinkAI Agents
The `linkai-agent` skill integrates all agents from [LinkAI](https://link-ai.tech/) as Skills, enabling multi-agent decision-making.
### Configuration
1. Configure `LINKAI_API_KEY` (via `env_config` tool or `linkai_api_key` in `config.json`)
2. Add agent descriptions in `skills/linkai-agent/config.json`:
```json
{
"apps": [
{
"app_code": "G7z6vKwp",
"app_name": "LinkAI Support",
"app_description": "Use this agent only for LinkAI platform questions"
},
{
"app_code": "SFY5x7JR",
"app_name": "Content Creator",
"app_description": "Use this agent for image or video creation"
}
]
}
```
The Agent selects the appropriate agent based on name and description, and calls the corresponding app via `app_code`.
<Frame>
<img src="https://cdn.link-ai.tech/doc/20260202234350.png" width="750" />
</Frame>
## Skill File Structure
Each skill directory follows this structure:
```
skills/
├── my-skill/
│ ├── SKILL.md # Skill description and instructions
│ ├── run.py # Execution script (optional)
│ └── resources/ # Additional resources (optional)
```
<Tip>
For custom skill development, see the [Skill Creator Guide](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md).
</Tip>