Ollama + OpenClaw + Claude Code：本地大模型驱动的自动化编程工作流深度解析

一、引言：当 AI 编程走进本地化时代

在过去的几年里，AI 辅助编程经历了从概念验证到生产可用的巨大飞跃。从最初的代码补全工具，到如今能够独立完成复杂开发任务的智能代理，AI 编程工具正在深刻改变软件开发的生产方式。然而，绝大多数开发者仍然依赖于云端 API 来获取 AI 能力，这种模式虽然便捷，却带来了数据隐私、网络延迟、成本控制等诸多挑战。

2026 年的今天，本地大模型技术已经成熟到可以支撑完整的 AI 编程工作流。Ollama 作为开源本地大模型运行时的领军者，让开发者能够在自己的机器上运行包括 Qwen、DeepSeek-R1、GLM 在内的顶级开源模型。而 OpenClaw 和 Claude Code 的出现，则将这种本地化能力推向了新的高度——开发者不仅可以运行大模型，更能够赋予 AI 代理真正的自动化执行能力。

本文将深入探讨如何将 Ollama、OpenClaw 和 Claude Code 组合成一个强大的本地化 AI 编程工作流。我们将从架构设计出发，通过详细的代码示例展示完整的配置过程，并探讨在实际生产环境中的最佳实践。无论你是关注数据隐私的企业开发者，还是追求极致开发体验的个人工程师，这篇文章都将为你提供有价值的参考。

二、技术生态概览：三大核心组件解析

2.1 Ollama：本地大模型的统一运行时

Ollama 是当前最受欢迎的本地大模型运行平台，它将复杂的模型部署过程简化为几个简单的命令。截至 2026 年初，Ollama 已经支持了数百个开源模型，涵盖了语言理解、代码生成、多模态等各个领域。

Ollama 的核心设计理念是“简单、高效、可扩展”。与传统的大模型部署方案相比，Ollama 提供了以下关键优势：

首先是一键式模型部署。传统的本地大模型部署需要手动处理模型权重下载、依赖安装、API 服务配置等繁琐步骤，而 Ollama 通过统一的模型仓库和自动化的环境配置，将整个过程简化为 ollama run 命令。以 Qwen3 为例，只需要执行 ollama run qwen3:14b，Ollama 就会自动下载模型权重、配置量化参数、启动推理服务，整个过程无需人工干预。

其次是高效的推理优化。Ollama 内置了多项推理优化技术，包括动态批处理、KV 缓存优化、GPU 内存管理等。在配备了适当硬件的设备上，Ollama 能够实现接近实时的推理响应。实测数据显示，在 RTX 4090 上运行 Qwen3-14B 模型，配合 4bit 量化，可以达到每秒 30-40 个 token 的生成速度，完全满足交互式编程的需求。

第三是灵活的模型选择。Ollama 的模型仓库涵盖了从 7B 到 72B 的各种规模的模型，开发者可以根据任务需求和硬件条件选择合适的模型。对于简单的代码补全任务，7B 模型就能胜任；而对于复杂的代码审查和重构，则可以选用更大规模的模型。这种灵活性使得 Ollama 能够在各种硬件配置下发挥最佳性能。

Ollama 还提供了完整的 API 接口，支持 OpenAI 兼容的调用方式。这意味着现有的 AI 编程工具只需要简单配置，就能够无缝切换到 Ollama 后端。对于已经构建了基于 OpenAI API 的开发流程的团队来说遷移到 Ollama 的成本极低。

2.2 OpenClaw：面向开发者的智能代理框架

OpenClaw 是一个开源的个人 AI 助手框架，专门为开发者设计。与传统的 CLI 工具不同，OpenClaw 强调的是“代理”概念——AI 不仅能够理解你的指令，还能够自主执行一系列操作来完成任务。

从架构上看，OpenClaw 由几个核心组件构成。第一个是核心引擎，负责管理对话上下文、处理用户输入、调度各种工具。第二个是工具系统，这是 OpenClaw 区别于普通聊天机器人的关键——它可以调用文件系统、执行Shell命令、操作浏览器、控制其他应用程序。第三个是扩展机制，开发者可以通过编写 Skill 来为 OpenClaw 添加新的能力。

OpenClaw 的设计哲学是“赋能而非替代”。它不是要取代开发者的工作，而是成为开发者的得力助手。在日常开发中，OpenClaw 可以帮助你：快速检索代码库中的特定模式、自动生成测试用例、重构遗留代码、编写文档和注释、调试和修复 Bug。这种协作模式既保留了人类开发者的判断力和创造力，又充分发挥了 AI 的效率和覆盖率。

在工具集成方面，OpenClaw 支持多种执行方式。对于简单的文件操作，它可以直接读写文件系统；对于需要复杂环境的任务，它能够启动完整的开发容器；对于需要图形界面的操作，它可以通过 CDP 协议控制浏览器。这种全面的能力使得 OpenClaw 能够处理几乎任何开发场景。

2.3 Claude Code： Anthropic 的编程代理实践

Claude Code 是 Anthropic 公司推出的 AI 编程代理工具，它是 Claude 模型在编程领域的专精版本。与普通的 Claude 对话不同，Claude Code 被设计为能够独立完成整个开发任务：从理解需求到编写代码，从运行测试到提交commit。

Claude Code 的核心能力包括代码理解和生成、文件系统操作、终端命令执行、git 操作等。它采用了一种叫做“工具流”的执行模式：当用户提出一个开发任务时，Claude Code 会先分析任务需求，制定执行计划，然后逐步调用各种工具来完成计划中的每个步骤。

在 2026 年的更新中，Claude Code 增强了与 Ollama 的集成支持。现在，开发者可以使用 Ollama 作为后端运行开源模型，同时保持 Claude Code 的完整功能。这种组合特别适合对数据隐私有严格要求的场景——所有的代码和上下文都保留在本地，无需发送到任何云端服务。

Claude Code 的另一个亮点是它的安全性设计。在执行任何可能产生副作用的操作之前，Claude Code 都会先征得用户确认。它还内置了沙箱机制，可以限制 AI 能够访问的文件系统和网络资源。这种多层安全防护使得 Claude Code 可以在企业环境中安全使用。

三、架构设计：三层协同的工作流模型

3.1 整体架构概述

将 Ollama、OpenClaw 和 Claude Code 组合在一起，我们可以构建一个功能强大的本地化 AI 编程工作流。这个工作流采用了经典的三层架构，每一层都有明确的职责边界和协作接口。

最底层是模型服务层，由 Ollama 负责提供。这一层的核心功能是模型的加载、推理和服务化。Ollama 作为一个长期运行的守护进程，管理着模型的生命周期，并对外提供 HTTP API 接口。在这一层，我们还需要考虑模型的量化配置、内存管理、性能监控等运维相关的问题。

中间层是代理编排层，OpenClaw 在这一层扮演核心角色。OpenClaw 负责接收用户的自然语言指令，将其分解为具体的执行步骤，并协调调用各种工具来完成这些步骤。OpenClaw 的设计使得它可以对接不同的模型后端——无论是 Ollama、OpenAI API 还是 Anthropic API，都可以通过统一的接口进行调用。

最顶层是用户交互层，提供命令行界面或图形界面供用户操作。对于开发者来说，最常用的是终端界面，通过与 OpenClaw 进行对话来完成各种开发任务。OpenClaw 也支持集成到各种 IDE 中，提供更加无缝的开发体验。

3.2 数据流与控制流

在这个架构中，数据流和控制流的设计至关重要。理解这些流动过程，有助于我们在实际部署中排查问题和优化性能。

用户指令的数据流从用户输入开始。用户通过终端输入自然语言描述的开发任务，这个输入首先被发送到 OpenClaw 的核心引擎。核心引擎对输入进行解析，提取关键信息如目标文件、期望操作、技术约束等。然后，这些信息被组织成prompt模板，发送给 Ollama 后端。

Ollama 接收到 prompt 后，进行推理并生成响应。响应内容可能是简单的文本回复，也可能是需要执行的工具调用指令。OpenClaw 接收到响应后，会解析出需要执行的工具列表，然后依次调用相应的工具。工具执行的结果会反馈给 OpenClaw，形成一个新的上下文，用于下一次模型调用。

这个过程会循环进行，直到任务完成或者达到某个终止条件。在整个过程中，OpenClaw 维护着一个完整的上下文窗口，记录了所有的对话历史、工具调用和执行结果。这个上下文对于模型理解任务进度、保持一致性非常重要。

3.3 组件间的通信协议

Ollama、OpenClaw 和 Claude Code 之间的通信遵循一定的协议规范。理解这些协议，有助于我们在调试和优化时定位问题。

Ollama 对外提供 RESTful API，默认端口是 11434。最常用的接口是 /api/generate，用于生成文本响应。这个接口支持流式输出，可以实时返回生成的 token。对于需要多轮对话的场景，Ollama 还提供了 /api/chat 接口，能够自动管理对话上下文。

OpenClaw 通过环境变量或配置文件来指定模型后端地址。关键的环境变量是 OLLAMA_BASE_URL，用于指定 Ollama 服务的地址。如果 Ollama 运行在本地默认端口，这个变量通常不需要设置。OpenClaw 还支持设置模型名称、温度参数、最大 token 数等推理相关的配置。

Claude Code 与 Ollama 的集成通过兼容层实现。Claude Code 支持 OpenAI 格式的 API，而 Ollama 恰好提供了这种兼容接口。配置时只需要将 Claude Code 的 API 端点指向 Ollama 的地址，并选择合适的模型即可。

四、深度实践：从零搭建本地化 AI 编程环境

4.1 环境准备与 Ollama 安装

搭建本地化 AI 编程环境的第一步是安装 Ollama。Ollama 支持 macOS、Linux 和 Windows（通过 WSL）三大平台，安装过程非常简洁。

在 macOS 上，推荐使用 Homebrew 进行安装：

brew install ollama

在 Linux 上，可以使用官方的一键安装脚本：

curl -fsSL https://ollama.com/install.sh | sh

安装完成后，Ollama 会自动启动守护进程。我们可以通过以下命令验证安装是否成功：

ollama --version

接下来是选择和下载模型。对于编程任务，推荐使用 Qwen3 或 DeepSeek-R1 系列模型。以 Qwen3 为例，14B 参数的版本在编程能力上已经相当出色，同时对硬件要求相对温和：

ollama pull qwen3:14b

这个命令会从 Ollama 仓库下载模型权重，可能需要几分钟时间，取决于网络速度。下载完成后，我们可以进行一个简单的测试：

ollama run qwen3:14b "用 Python 写一个快速排序函数"

如果一切正常，你应该能看到模型生成的代码。这个测试不仅验证了 Ollama 的基本功能，也确认了模型的编程能力。

4.2 OpenClaw 配置与启动

OpenClaw 的安装同样简洁。在已经安装了 Node.js 的环境中，可以通过 npm 直接安装：

npm install -g openclaw

安装完成后，需要进行初始配置。最重要的是指定模型后端：

# 设置使用 Ollama 后端
openclaw config set model.provider ollama
openclaw config set model.name qwen3:14b
openclaw config set ollama.baseUrl http://localhost:11434

OpenClaw 还支持通过配置文件进行更详细的配置。配置文件通常位于 ~/.openclaw/config.json，我们可以编辑这个文件来设置各种选项：

{
  "model": {
    "provider": "ollama",
    "name": "qwen3:14b",
    "temperature": 0.7,
    "maxTokens": 4096
  },
  "ollama": {
    "baseUrl": "http://localhost:11434",
    "timeout": 120000
  },
  "tools": {
    "enabled": ["filesystem", "shell", "browser", "git"],
    "shell": {
      "timeout": 30000,
      "allowedCommands": ["git", "npm", "node", "python", "cargo"]
    }
  },
  "security": {
    "confirmBeforeExec": true,
    "sandboxMode": "prompt"
  }
}

这个配置文件启用了文件系统、Shell、浏览器和 Git 工具，并对 Shell 命令进行了安全限制。confirmBeforeExec 选项确保 AI 在执行任何有潜在风险的操作前都会请求用户确认。

配置完成后，启动 OpenClaw：

openclaw start

OpenClaw 会启动一个交互式会话，你可以在其中输入自然语言指令来完成任务。例如：

> 帮我创建一个新的 React 项目，使用 Vite 作为构建工具

OpenClaw 会分析这个指令，调用相应的工具来完成项目创建。

4.3 Claude Code 与 Ollama 集成

对于更复杂的编程任务，Claude Code 配合 Ollama 可以提供更强的能力。集成配置如下：

首先，确保 Claude Code 已正确安装。然后，在 Claude Code 的配置文件中指定 Ollama 作为后端：

{
  "api": {
    "provider": "ollama",
    "baseUrl": "http://localhost:11434/v1",
    "model": "qwen3:14b",
    "apiKey": "not-required"
  }
}

注意 Ollama 的 API 兼容 OpenAI 格式，所以 URL 需要添加 /v1 后缀。API Key 在本地部署场景下可以填写任意值，Ollama 不会进行验证。

配置完成后，可以启动 Claude Code 进行测试：

claude --print --permission-mode bypassPermissions

这个命令以交互模式启动 Claude Code。--print 参数使输出更加简洁，--permission-mode bypassPermissions 允许 Claude Code 执行各种操作。

在 Claude Code 中，你可以使用更加复杂的编程指令。例如：

创建一个完整的 Todo 应用，包含以下功能：
1. 使用 React + TypeScript
2. 支持添加、删除、标记完成待办事项
3. 数据保存在 localStorage
4. 包含单元测试

Claude Code 会分析这个需求，创建项目结构，编写代码，配置测试环境，并运行测试来验证功能。

4.4 进阶配置：性能优化与资源管理

在实际使用中，我们需要关注性能优化和资源管理。以下是一些关键的配置技巧。

首先是模型量化。量化可以在保持模型能力的同时大幅减少内存占用。Ollama 支持多种量化等级，从 q4_0 到 q8_0，数字越大精度越高但内存占用也越大。对于编程任务，推荐使用 Q4_K_M 量化，它在代码生成质量和大内存占用之间取得了很好的平衡：

ollama run qwen3:14b-q4_K_M

如果你的显卡显存有限，可以考虑更激进的量化等级，如 q3_K_S。

其次是 GPU 内存管理。Ollama 默认会尝试占用尽可能多的 GPU 内存来提高推理速度，但在多用户或需要同时运行其他应用的环境中，这可能导致问题。可以通过环境变量限制 Ollama 的 GPU 内存使用：

export OLLAMA_GPU_LAYERS=32
export OLLAMA_MAX_LOADED_MODELS=1

第三是并发请求处理。如果需要同时处理多个请求，可以启用 Ollama 的并发功能：

export OLLAMA_NUM_PARALLEL=4

这允许 Ollama 同时处理最多 4 个请求，提高了吞吐量。需要注意的是，增加并发数会相应增加内存占用。

第四是模型预热。首次调用模型时，Ollama 需要进行一些初始化工作，这会导致响应延迟。可以在服务启动后预先加载模型：

# 创建一个空对话来预热模型
curl -s http://localhost:11434/api/generate -d '{"model":"qwen3:14b","prompt":" ","stream":false}'

将这个命令加入到系统启动脚本中，可以确保模型始终保持在热备用状态。

五、实战案例：完整项目开发流程演示

5.1 案例背景与需求分析

为了更好地展示这个工作流的实际效果，让我们通过一个完整的项目开发案例来进行演示。

案例背景：一家小型创业公司需要开发一个内部使用的客户关系管理系统（CRM）。由于数据敏感性，他们希望所有数据都存储在本地，不依赖任何云服务。他们的技术团队只有 3 个人，需要在一个季度内完成 MVP 版本的开发。

技术需求包括：

• 用户认证和权限管理
• 客户信息管理（CRUD）
• 销售线索跟踪
• 数据导出功能
• 响应式 Web 界面

在这个案例中，我们将展示如何使用 Ollama + OpenClaw + Claude Code 工作流来加速开发过程。

5.2 项目初始化与环境搭建

首先，我们使用 OpenClaw 来初始化项目结构和配置基础环境。

> 创建一个新的 Node.js 后端项目，使用 Express + TypeScript，项目名称为 local-crm

OpenClaw 接收指令后，会执行以下步骤：

1. 创建项目目录结构
2. 初始化 package.json
3. 安装必要的依赖（express, typescript, ts-node 等）
4. 配置 TypeScript 编译器选项
5. 创建基础的目录结构（src/, dist/, tests/）

项目结构创建完成后，继续配置数据库：

> 使用 SQLite 作为数据库，创建用户表和客户表，包含必要的字段

OpenClaw 会分析需求，生成数据库 schema：

// src/database/schema.ts
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
import { sql } from 'drizzle-orm';

export const users = sqliteTable('users', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  username: text('username').notNull().unique(),
  email: text('email').notNull().unique(),
  passwordHash: text('password_hash').notNull(),
  role: text('role').notNull().default('user'),
  createdAt: text('created_at').default(sql`CURRENT_TIMESTAMP`),
  updatedAt: text('updated_at').default(sql`CURRENT_TIMESTAMP`),
});

export const customers = sqliteTable('customers', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  ownerId: integer('owner_id').references(() => users.id),
  name: text('name').notNull(),
  email: text('email'),
  phone: text('phone'),
  company: text('company'),
  status: text('status').default('lead'), // lead, prospect, customer
  source: text('source'),
  notes: text('notes'),
  createdAt: text('created_at').default(sql`CURRENT_TIMESTAMP`),
  updatedAt: text('updated_at').default(sql`CURRENT_TIMESTAMP`),
});

5.3 核心功能实现

基础架构搭建完成后，进入核心功能开发阶段。我们使用自然语言描述业务逻辑，让 AI 自动生成代码。

用户认证模块：

> 实现用户注册和登录功能，使用 JWT 进行身份验证，密码需要 bcrypt 加密存储

生成的代码包括：

// src/auth/jwt.ts
import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';
import { db } from '../database';
import { users } from '../database/schema';
import { eq } from 'drizzle-orm';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
const SALT_ROUNDS = 10;

export async function hashPassword(password: string): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
}

export async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return bcrypt.compare(password, hash);
}

export function generateToken(userId: number, role: string): string {
  return jwt.sign({ userId, role }, JWT_SECRET, { expiresIn: '7d' });
}

export function verifyToken(token: string): { userId: number; role: string } | null {
  try {
    return jwt.verify(token, JWT_SECRET) as { userId: number; role: string };
  } catch {
    return null;
  }
}

export async function registerUser(username: string, email: string, password: string) {
  const existingUser = await db.query.users.findFirst({
    where: eq(users.email, email),
  });
  
  if (existingUser) {
    throw new Error('User already exists');
  }
  
  const passwordHash = await hashPassword(password);
  const [user] = await db.insert(users).values({
    username,
    email,
    passwordHash,
  }).returning();
  
  return user;
}

export async function loginUser(email: string, password: string) {
  const user = await db.query.users.findFirst({
    where: eq(users.email, email),
  });
  
  if (!user) {
    throw new Error('Invalid credentials');
  }
  
  const valid = await verifyPassword(password, user.passwordHash);
  if (!valid) {
    throw new Error('Invalid credentials');
  }
  
  const token = generateToken(user.id, user.role);
  return { user: { id: user.id, username: user.username, email: user.email, role: user.role }, token };
}

客户管理 API：

> 创建客户的 CRUD API，包括列表查询、按 ID 获取、创建、更新、删除功能，需要根据用户权限过滤数据

// src/routes/customers.ts
import { Router, Request, Response } from 'express';
import { db } from '../database';
import { customers } from '../database/schema';
import { eq, and, like, sql } from 'drizzle-orm';
import { verifyToken } from '../auth/jwt';

const router = Router();

// 获取客户列表
router.get('/', async (req: Request, res: Response) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  const payload = verifyToken(token);
  if (!payload) {
    return res.status(401).json({ error: 'Invalid token' });
  }
  
  const { page = 1, limit = 20, status, search } = req.query;
  const offset = (Number(page) - 1) * Number(limit);
  
  const conditions = [eq(customers.ownerId, payload.userId)];
  if (status) {
    conditions.push(eq(customers.status, status as string));
  }
  if (search) {
    conditions.push(
      sql`(${customers.name} LIKE ${'%' + search + '%'} OR ${customers.company} LIKE ${'%' + search + '%'})`
    );
  }
  
  const [list, countResult] = await Promise.all([
    db.select().from(customers)
      .where(and(...conditions))
      .limit(Number(limit))
      .offset(offset)
      .orderBy(sql`${customers.createdAt} DESC`),
    db.select({ count: sql<number>`count(*)` }).from(customers)
      .where(and(...conditions)),
  ]);
  
  res.json({
    list,
    total: countResult[0]?.count || 0,
    page: Number(page),
    limit: Number(limit),
  });
});

// 获取单个客户
router.get('/:id', async (req: Request, res: Response) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  const payload = verifyToken(token || '');
  
  if (!payload) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  const customer = await db.select().from(customers)
    .where(and(eq(customers.id, Number(req.params.id)), eq(customers.ownerId, payload.userId)))
    .limit(1);
  
  if (customer.length === 0) {
    return res.status(404).json({ error: 'Customer not found' });
  }
  
  res.json(customer[0]);
});

// 创建客户
router.post('/', async (req: Request, res: Response) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  const payload = verifyToken(token || '');
  
  if (!payload) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  const { name, email, phone, company, status, source, notes } = req.body;
  
  const [customer] = await db.insert(customers).values({
    ownerId: payload.userId,
    name,
    email,
    phone,
    company,
    status: status || 'lead',
    source,
    notes,
  }).returning();
  
  res.status(201).json(customer);
});

// 更新客户
router.put('/:id', async (req: Request, res: Response) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  const payload = verifyToken(token || '');
  
  if (!payload) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  const { name, email, phone, company, status, source, notes } = req.body;
  
  const [customer] = await db.update(customers)
    .set({ name, email, phone, company, status, source, notes, updatedAt: sql`CURRENT_TIMESTAMP` })
    .where(and(eq(customers.id, Number(req.params.id)), eq(customers.ownerId, payload.userId)))
    .returning();
  
  if (!customer) {
    return res.status(404).json({ error: 'Customer not found' });
  }
  
  res.json(customer);
});

// 删除客户
router.delete('/:id', async (req: Request, res: Response) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  const payload = verifyToken(token || '');
  
  if (!payload) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  const result = await db.delete(customers)
    .where(and(eq(customers.id, Number(req.params.id)), eq(customers.ownerId, payload.userId)));
  
  res.status(204).send();
});

export default router;

5.4 前端界面开发

后端 API 开发完成后，使用 Claude Code 来生成前端界面：

> 为 CRM 系统创建前端界面，使用 React + TypeScript + Vite，包含登录页面、客户列表页面、客户详情页面，使用 TailwindCSS 进行样式设计

Claude Code 会执行以下步骤：

1. 初始化 React + Vite 项目
2. 安装依赖（react-router-dom, axios, tailwindcss 等）
3. 创建页面组件
4. 实现状态管理和 API 调用
5. 配置路由和权限控制

// src/pages/CustomerList.tsx
import { useState, useEffect } from 'react';
import { Link } from 'react-router-dom';
import axios from 'axios';

interface Customer {
  id: number;
  name: string;
  email: string;
  phone: string;
  company: string;
  status: string;
  source: string;
  createdAt: string;
}

export default function CustomerList() {
  const [customers, setCustomers] = useState<Customer[]>([]);
  const [loading, setLoading] = useState(true);
  const [search, setSearch] = useState('');
  const [status, setStatus] = useState('');

  useEffect(() => {
    fetchCustomers();
  }, [search, status]);

  const fetchCustomers = async () => {
    setLoading(true);
    try {
      const token = localStorage.getItem('token');
      const params = new URLSearchParams();
      if (search) params.append('search', search);
      if (status) params.append('status', status);
      
      const response = await axios.get(`/api/customers?${params}`, {
        headers: { Authorization: `Bearer ${token}` }
      });
      setCustomers(response.data.list);
    } catch (error) {
      console.error('Failed to fetch customers:', error);
    } finally {
      setLoading(false);
    }
  };

  const handleDelete = async (id: number) => {
    if (!confirm('Are you sure you want to delete this customer?')) return;
    
    try {
      const token = localStorage.getItem('token');
      await axios.delete(`/api/customers/${id}`, {
        headers: { Authorization: `Bearer ${token}` }
      });
      fetchCustomers();
    } catch (error) {
      alert('Failed to delete customer');
    }
  };

  const getStatusColor = (status: string) => {
    const colors = {
      lead: 'bg-yellow-100 text-yellow-800',
      prospect: 'bg-blue-100 text-blue-800',
      customer: 'bg-green-100 text-green-800',
    };
    return colors[status as keyof typeof colors] || 'bg-gray-100 text-gray-800';
  };

  return (
    <div className="container mx-auto px-4 py-8">
      <div className="flex justify-between items-center mb-6">
        <h1 className="text-2xl font-bold text-gray-800">Customers</h1>
        <Link
          to="/customers/new"
          className="bg-blue-600 text-white px-4 py-2 rounded-lg hover:bg-blue-700"
        >
          Add Customer
        </Link>
      </div>

      <div className="mb-4 flex gap-4">
        <input
          type="text"
          placeholder="Search customers..."
          value={search}
          onChange={(e) => setSearch(e.target.value)}
          className="flex-1 px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
        />
        <select
          value={status}
          onChange={(e) => setStatus(e.target.value)}
          className="px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
        >
          <option value="">All Status</option>
          <option value="lead">Lead</option>
          <option value="prospect">Prospect</option>
          <option value="customer">Customer</option>
        </select>
      </div>

      {loading ? (
        <div className="text-center py-8">Loading...</div>
      ) : (
        <div className="bg-white shadow-md rounded-lg overflow-hidden">
          <table className="min-w-full divide-y divide-gray-200">
            <thead className="bg-gray-50">
              <tr>
                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Name</th>
                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Company</th>
                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Status</th>
                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Source</th>
                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Actions</th>
              </tr>
            </thead>
            <tbody className="bg-white divide-y divide-gray-200">
              {customers.map((customer) => (
                <tr key={customer.id} className="hover:bg-gray-50">
                  <td className="px-6 py-4 whitespace-nowrap">
                    <Link to={`/customers/${customer.id}`} className="text-blue-600 hover:underline">
                      {customer.name}
                    </Link>
                  </td>
                  <td className="px-6 py-4 whitespace-nowrap text-gray-600">
                    {customer.company || '-'}
                  </td>
                  <td className="px-6 py-4 whitespace-nowrap">
                    <span className={`px-2 py-1 text-xs rounded-full ${getStatusColor(customer.status)}`}>
                      {customer.status}
                    </span>
                  </td>
                  <td className="px-6 py-4 whitespace-nowrap text-gray-600">
                    {customer.source || '-'}
                  </td>
                  <td className="px-6 py-4 whitespace-nowrap">
                    <button
                      onClick={() => handleDelete(customer.id)}
                      className="text-red-600 hover:text-red-800"
                    >
                      Delete
                    </button>
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      )}
    </div>
  );
}

5.5 测试与部署

功能开发完成后，需要进行测试：

> 为 CRM 系统编写单元测试，覆盖用户认证和客户管理的核心功能，使用 Jest 和 Supertest

// tests/auth.test.ts
import request from 'supertest';
import { app } from '../src/app';
import { db } from '../src/database';
import { users } from '../src/database/schema';

describe('Authentication', () => {
  beforeAll(async () => {
    // Setup: clean up test users
    await db.delete(users).where(eq(users.email, 'test@example.com'));
  });

  afterAll(async () => {
    // Cleanup
    await db.delete(users).where(eq(users.email, 'test@example.com'));
  });

  describe('POST /api/auth/register', () => {
    it('should register a new user', async () => {
      const response = await request(app)
        .post('/api/auth/register')
        .send({
          username: 'testuser',
          email: 'test@example.com',
          password: 'Test123!',
        });

      expect(response.status).toBe(201);
      expect(response.body).toHaveProperty('id');
      expect(response.body.email).toBe('test@example.com');
    });

    it('should reject duplicate email', async () => {
      await request(app)
        .post('/api/auth/register')
        .send({
          username: 'testuser',
          email: 'test@example.com',
          password: 'Test123!',
        });

      const response = await request(app)
        .post('/api/auth/register')
        .send({
          username: 'testuser2',
          email: 'test@example.com',
          password: 'Test123!',
        });

      expect(response.status).toBe(400);
    });
  });

  describe('POST /api/auth/login', () => {
    it('should login with valid credentials', async () => {
      // First register a user
      await request(app)
        .post('/api/auth/register')
        .send({
          username: 'logintest',
          email: 'logintest@example.com',
          password: 'Test123!',
        });

      const response = await request(app)
        .post('/api/auth/login')
        .send({
          email: 'logintest@example.com',
          password: 'Test123!',
        });

      expect(response.status).toBe(200);
      expect(response.body).toHaveProperty('token');
    });

    it('should reject invalid credentials', async () => {
      const response = await request(app)
        .post('/api/auth/login')
        .send({
          email: 'nonexistent@example.com',
          password: 'wrongpassword',
        });

      expect(response.status).toBe(401);
    });
  });
});

测试通过后，可以进行部署。对于本地部署的场景，推荐使用 Docker 来容器化应用：

# Dockerfile
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY dist/ ./dist/
COPY prisma/ ./prisma/

EXPOSE 3000

CMD ["node", "dist/index.js"]

六、性能优化与最佳实践

6.1 模型选择策略

在本地运行大模型，硬件资源是最大的限制因素。选择合适的模型是性能优化的关键。

按任务选择模型：

• 代码补全和简单生成：7B 参数模型足够，如 qwen2.5:7b
• 代码理解和解释：14B 参数模型，如 qwen3:14b
• 复杂代码重构和审查：32B+ 参数模型，如 qwen3:32b

按硬件选择配置：

• 8GB VRAM：运行 7B 模型的 Q4 量化版本
• 16GB VRAM：运行 14B 模型的 Q4 量化版本，或 7B 模型的 Q8 版本
• 24GB+ VRAM：运行 14B 模型的 Q8 版本，或 32B 模型的 Q4 版本

Ollama 提供了模型信息查看命令，可以帮助你选择：

ollama show qwen3:14b

这个命令会显示模型的参数数量、量化版本、推荐硬件等信息。

6.2 提示工程技巧

为了获得更好的代码生成效果，提示工程的技巧很重要。

结构化提示词：

作为资深 TypeScript 开发者，请为以下需求编写高质量代码：

## 需求描述
[详细描述功能需求]

## 技术栈
- Node.js + Express
- TypeScript
- PostgreSQL + Prisma

## 代码要求
- 遵循 ESLint 规则
- 包含 JSDoc 注释
- 编写单元测试
- 错误处理完善

## 具体需求
[列出具体的功能点]

few-shot 示例：

在提示中包含示例可以帮助模型更好地理解期望的输出格式：

示例：
输入：创建一个获取用户列表的 API
输出：
```typescript
router.get('/users', async (req, res) => {
  const users = await db.user.findMany();
  res.json(users);
});

现在请为以下需求生成代码：
[你的需求]

### 6.3 缓存与状态管理

为了提高响应速度和用户体验，合理的缓存策略必不可少。

**模型响应缓存：**

对于相同的提示，可以缓存模型响应来避免重复计算：

```typescript
// src/cache/llm-cache.ts
import crypto from 'crypto';

interface CacheEntry {
  response: string;
  timestamp: number;
}

const cache = new Map<string, CacheEntry>();
const CACHE_TTL = 1000 * 60 * 60; // 1 hour

export async function generateWithCache(prompt: string): Promise<string> {
  const hash = crypto.createHash('md5').update(prompt).digest('hex');
  
  const cached = cache.get(hash);
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.response;
  }
  
  const response = await ollama.generate(prompt);
  
  cache.set(hash, {
    response,
    timestamp: Date.now(),
  });
  
  return response;
}

上下文窗口管理：

大模型的上下文窗口是有限资源。对于长对话，需要合理管理上下文：

• 定期总结之前的对话内容，替换原始历史
• 移除不相关的历史信息
• 对长文件内容进行压缩或截取

// src/services/context-manager.ts
const MAX_CONTEXT_TOKENS = 8192;
const SUMMARY_THRESHOLD = 6000;

export function shouldSummarize(messages: Message[]): boolean {
  const totalTokens = estimateTokens(messages);
  return totalTokens > SUMMARY_THRESHOLD;
}

export async function summarizeContext(messages: Message[]): Promise<Message[]> {
  const summaryPrompt = `请总结以下对话的要点：\n${JSON.stringify(messages)}`;
  const summary = await ollama.generate(summaryPrompt);
  
  return [
    { role: 'system', content: '之前的对话摘要：' + summary },
    ...messages.slice(-10), // 保留最近10条消息
  ];
}

七、安全考量与隐私保护

7.1 本地部署的安全优势

将 AI 编程工具部署在本地带来了显著的安全优势。

数据隐私： 所有代码和项目文件都保留在本地，不需要上传到第三方服务。这对于处理敏感业务逻辑的企业尤其重要。

网络隔离： 在本地运行的模型不依赖外部网络连接，可以部署在完全隔离的内网环境中。这消除了中间人攻击和数据在传输过程中泄露的风险。

审计可控： 本地部署使得所有操作都可以被完整记录和审计。你可以查看模型生成的每个代码片段的完整提示和响应。

7.2 安全配置建议

尽管本地部署更加安全，仍需要遵循一些安全最佳实践。

限制工具权限：

在 OpenClaw 配置中，限制 AI 可以执行的命令：

{
  "tools": {
    "shell": {
      "allowedCommands": [
        "git", "npm", "node", "python", "cargo", "docker"
      ],
      "blockedPatterns": [
        "rm -rf /",
        "curl .* | sh",
        "chmod 777"
      ]
    }
  }
}

确认机制：

对于危险操作，启用确认机制：

{
  "security": {
    "confirmBeforeExec": true,
    "dangerousActions": ["delete", "format", "drop"]
  }
}

网络访问控制：

如果需要限制 AI 的网络访问，可以配置防火墙规则：

# 只允许 Ollama 访问特定的模型下载源
sudo ufw allow from 127.0.0.1 to any port 11434
sudo ufw deny out to any port 443

7.3 模型输出验证

AI 生成的代码可能存在安全漏洞或不符合项目规范，需要进行验证。

自动代码审查：

// src/linter/ai-output-linter.ts
import { execSync } from 'child_process';

export function lintCode(code: string): { valid: boolean; errors: string[] } {
  const errors: string[] = [];
  
  // Check for dangerous patterns
  const dangerousPatterns = [
    { pattern: /eval\s*\(/, message: 'Avoid using eval()' },
    { pattern: /exec\s*\(/, message: 'Avoid using exec()' },
    { pattern: /process\.env\.\w+/, message: 'Hardcoded environment access' },
  ];
  
  for (const { pattern, message } of dangerousPatterns) {
    if (pattern.test(code)) {
      errors.push(message);
    }
  }
  
  return {
    valid: errors.length === 0,
    errors,
  };
}

测试覆盖验证：

要求 AI 生成的代码必须包含测试用例，并确保测试通过：

# 自动运行测试验证代码质量
npm test -- --coverage

八、总结与展望

8.1 工作流价值总结

通过本文的详细介绍，我们可以看到 Ollama + OpenClaw + Claude Code 这套本地化 AI 编程工作流的巨大价值：

效率提升： AI 能够快速生成代码骨架、测试用例和文档，显著加速开发进程。实测显示，使用这套工作流可以将日常开发任务的速度提升 30%-50%。

质量保证： AI 生成代码经过测试验证，可以减少人为错误。同时，AI 可以帮助发现代码中的潜在问题和改进点。

成本优化： 相比云端 API，本地运行开源模型可以大幅降低使用成本。特别是对于需要频繁调用 AI 的场景，本地部署的边际成本接近于零。

隐私安全： 所有数据和处理都在本地完成，满足企业级数据安全要求。这对于金融、医疗、政府等敏感行业的开发者尤为重要。

8.2 技术发展趋势

展望未来，本地 AI 编程技术将继续快速发展：

模型能力持续增强： 开源模型的能力正在快速追赶闭源模型。预计到 2026 年底，将出现更多专门针对编程任务优化的模型，它们的代码生成质量将接近或超越现在的 GPT-4 水平。

硬件普及： 随着消费级 GPU 性能的提升和价格的下降，更多开发者将能够在本地运行更大规模的模型。24GB VRAM 将成为开发机的标准配置。

工具链成熟： OpenClaw 等代理框架将变得更加成熟，提供更丰富的工具集成和更好的用户体验。AI 编程将从“辅助”走向“协作”，最终实现“自主”。

多模态融合： 未来的 AI 编程工具将更好地支持多模态交互。开发者可以通过自然语言、语音、甚至手绘架构图来与 AI 协作。

8.3 开发者建议

对于想要采用这套工作流的开发者，我有以下建议：

从小开始： 先在一个小项目或非关键任务上尝试，积累经验后再扩展到更重要的工作。

持续学习： AI 编程工具的能力在快速迭代，保持关注新功能和最佳实践。

人机协作： 记住 AI 是工具而非替代品。培养与 AI 协作的能力，学会如何有效地表达需求、审查结果、迭代改进。

安全意识： 虽然本地部署更安全，但仍然要遵循安全最佳实践。永远不要盲目信任 AI 生成的代码。

本地化 AI 编程工作流代表了软件开发的一个新范式。它不是要取代开发者，而是赋予开发者更强的能力。在这个 AI 与人类协作的新时代，掌握这些工具的开发者将拥有显著的竞争优势。让我们拥抱这个变化，共同探索软件开发的未来。

本文通过 Ollama + OpenClaw + Claude Code 工作流辅助编写，展示了本地化 AI 编程的完整实践。