大模型的开发模式

开发模式

模式总结

人机协同三种模式

AI Embedded 嵌入：某个环节里去调用大模型
使用提示词来设定目标，与AI进行语言交流，然后AI协助完成目标
AI Copilot 辅助：每个环节都可以跟大模型进行交互
人类和AI各自发挥作用，AI介入到工作流程中，从提供建议到协助完成流程的各个阶段。
AI Agent 代理：任务交给大模型，大模型即可自行计划、分解和自动执行
人类设定目标并提供资源（计算能力），然后监督结果。
Agent承担了大部分工作。
AutoGPT代表了一种完全自动化的实现方式，试图抵达AGI的理想状态，即提出需求后机器人能够自动完成任务
AI技术的自动化范式 —— AutoGPT
基于Agents的自动化团队——GPTeam，许多流程都可以被自动化执行。市场调研、问卷调查、品牌计划等等，都可以由AI来完成。
自动化品牌营销公司——AutoCorp
Society 模式

【2023-11-21】更完整的图解

第三种模式将成为未来人机交互的主要模式。

方案一：AI Copilot 辅助

以LLM为核心，end2end架构实现新版对话系统，用prompt engineering复现原有主要模块

既然大模型（尤其是GPT系列）这么厉害，下游任务只需调prompt，那就用prompt去完成对话功能，替换原有功能模块就好了。

角色模拟：system prompt中设置即可，大模型的强项
闲聊任务：满足，一次调用即可
简易问答：如果是通用领域知识，一次调用即可，如果是垂直领域，需要额外融入知识（prompt中植入/微调），如果涉及实时查询、工具，还需要结合Plugin、Function Call，一般1-3次调用
多轮任务：prompt中设置对话逻辑（类似上一代有限状态机FSM），简单任务满足，功能接口借助Plugin、Function Call实现，同时增加记忆单元（如借助LangChain），但复杂任务不好办，如：任务状态处理逻辑复杂、场景嵌套、API较多等。即便是FSM场景也受限（如图），而订餐这类场景只是多轮对话中的一种简单形式，至于更复杂的循环、中断、嵌套、多阶就不用提了，如信用卡业务场景下，各种流程跳转，简易对话无能为力，只好用比FSM（图）更高级的方法，Frame（槽填充+树）、Goal（树+栈+字典），大模型用data-driven结合强化学习更合适。

推荐型：边聊边推，设计推荐的prompt，一次调用，但依赖具体形态，聊天场景推荐对时延要求低，启用流式输出可以缓冲，而输入是输入提示这类场景，大模型的速度就堪忧了。

全部采用大模型后，以常规的对话系统为例，一次对话过程可能涉及1~10次大模型调用，这用户体验可想而知。

这种思路是把原来对话系统所有的功能都用生成式方法（自回归语言模型，GPT为代表）解决，实际上，生成式只是小部分，大部分任务是理解式任务（掩码语言模型，BERT为代表），如意图识别、槽位抽取、状态跟踪等输出空间有限，这时用生成式方法，天然就慢半拍。

实际落地时，新的问题出来了：

极度依赖prompt：提示语稍微变更下，加个空格，结果可能就相差十万八千里，每个场景都需要仔细调试prompt，换个模型又要重新开始。
速度慢：实在是慢，正常情况1-3s回复，如果句子长，要持续等待，直至流式输出结束。这对高并发、低时延要求的对话产品简直是“噩耗”。
不可控：即便在prompt里明确要求不要超过30字，结果LLM当成耳边风，还是会超出字数。任务型对话里的业务处理逻辑往往要求准确无误了。
幻觉：一本正经的胡说八道
黑盒：大模型到底是怎么执行对话策略的？不知道，充满了玄学意味，涌现到底是个啥？这对高度可控的场景十分致命。

对于速度问题，短期内只能依靠别的方法提速了，如：

各种模型加速推理技术
部分功能回退：如不适合生成式方法的NLU/DM
推进end2end方法：将多轮会话训入大模型，延续之前的end2end思路

方案二：AI Embedded 嵌入

在LLM基础上，加领域语料，增量预训练、微调，融入领域知识，根据业务场景，增加特殊逻辑

这部分涉及两部分工作

基座大模型训练：各行各业都在训自己的大模型，金融、医疗、教育、数字人，甚至宗教
业务场景落地：适配业务场景，升级或重构现有对话产品的局部

各行各业都在训自己的大模型，金融、医疗、教育、数字人，甚至宗教

人物个性模拟上

国外有 Character.ai，用户根据个人偏好定制 AI 角色并和它聊天；
国内有阿里的脱口秀版GPT——鸟鸟分鸟，并且已经在天猫精灵上为个人终端行业的客户做了演示

应用场景很多，略

方案三：AI Agent 代理

抛弃过往模块化思路，站在任务角度，通过Agent去执行对话任务，如：

最近不少人不再卷大模型了，开始卷 AI Agents

LLM诞生之初，大家对于其能力的边界还没有清晰的认知，以为有了LLM就可以直通AGI了，路线: LLM -> AGI
过了段时间，发现LLM的既有问题（幻觉问题、容量限制…），并不能直接到达AGI，于是路线变成了: LLM -> Agent -> AGI
借助一个/多个Agent，构建一个新形态，继续实现通往AGI的道路。但这条路是否能走通，以及还面临着哪些问题，有待进一步验证。

由于大模型的出现，AI Agents 衍生出了一种新的架构形式: 《LLM Powered Autonomous Agents》

将最重要的「任务规划」部分或完全交由LLM，而做出这一设计的依据在于默认：LLM具有任务分解和反思的能力。

最直观的公式

Agent = LLM + Planning + Feedback + Tool use

这种思路更加灵活，贴近AGI，想象空间巨大，成为继模型训练后又一个角斗场。

详见往期文章：大模型智能体

LLM 开发范式

开发范式总结

总结: 预训练(pre-training) → 微调(fine-tune) → 提示工程(prompt engineering)

（1）pre-training(预训练)： 通识教育，教小孩认字、学算数、做推理，这个步骤产出基础大模型。
（2）fine-tune(微调)：专业课，比如学法律的会接触一些法律的条款、法律名词；学计算机的会知道什么叫计算机语言。
（3）prompt engineering(提示工程)：职业训练，AI应用的准确率要达到商用级别（超过人的准确率），就需要 prompt engineer，PE 重要性

有些场景中（2）可以省略。

开发范式演进

LLM时代Prompt Engineer开发范式

第一层：简单Prompt: 即编写一个提示词（Prompt）去调用大模型，最简单。
第二层：Plugin插件: 用大模型插件（Plugin）去调各种API，以及Function Call。
第三层：Prompt Engineering Workflow + OpenAI API
- 基于提示词工程的工作流（workflow）编排。AI应用就是基于工作流实现。
第四层：向量数据库集成 RAG
- 向量数据库包含数据特征值，落地方案如 VectorDB，包括做知识库、做客服机器人。
第五层：AI Agents, 让大模型自己做递归。
- Agent 原理: AI自己对任务进行拆解，再进一步递归、继续拆解，直到有一步，AI可以将这个任务执行，最后再将任务合并起来，往前递归回来，合并为一个工程。
第六层：领域模型 Domain Model
- 专业模型为什么重要？大参数基础模型的训练和推理成本非常高，而专业模型速度快、成本低、准确率高，因为有行业的高质量数据，所以准确率高；进而可以形成数据飞轮，形成自己的竞争优势。

LLM应用架构范式

【2024-3-25】大模型应用的10种架构模式

路由分发模式: 将用户query发到控制中心，分发到不同领域小模型/大模型。更准确、响应更快且成本更低，平衡成本/性能与体验
大模型代理模式: 大模型充当代理角色，分析用户意图，结合上下文路由到不同专有小模型，适合复杂问题解
多任务微调模式: 微调大模型，同时处理多个任务，适合复杂任务平台, 如虚拟助理或是人工智能驱动的研究工具。
面向微调的分层缓存策略模式: 将缓存策略和相关服务引入大模型应用架构，解决成本、数据冗余以及训练数据等组合问题。
- 缓存初始QA结果, 积累到一定量后, 微调训练专有小模型，同时参考缓存和专用模型，适合高准确、适应性环境, 如客户服务或个性化内容创建
- 工具： GPTCache，或缓存数据库，如 Redis、Cassandra、Memcached 运行服务
混合规则模式: 将大模型与业务规则逻辑结合，适合需要严格遵守标准或法规的行业或产品，如电话IVR系统或基于规则的传统（非LLM）聊天机器人的意图和消息流
知识图谱模式: 将知识图谱与大模型结合，赋予面向事实的超级能力，使得输出不仅具有上下文情境，而且更加符合事实。
- 适合: 要求内容真实性和准确性的应用，比如在教育内容创作、医疗咨询或任何误导可能带来严重后果的领域
- 知识图谱及其本体将复杂主题或问题分解成结构化格式，为大型语言模型提供深层上下文基础。甚至可以借助语言模型，以JSON或RDF等格式创建本体。
- 构建知识图谱的图数据库服务: ArangoDB、Amazon Neptune、Google Dgraph、Azure Cosmos DB以及Neo4j等。此外，更广泛的数据集和服务也能用于访问更全面的知识图谱，包括开源的企业知识图谱API、PyKEEN数据集以及Wikidata等等。
智能体蜂巢模式: 运用大量AI Agent，共同协作以解决问题，每个代理都从各自独特的视角出发进行贡献。
智能体组合模式: 大模型系统模块化, 自我配置以优化任务性能。
- 自主代理框架和体系结构来开发每个Agent及其工具，例如CrewAI、Langchain、LLamaIndex、Microsoft Autogen和superAGI等
记忆认知模式: 仿照人类记忆, 允许模型回忆并基于过去的交互进行学习，从而产生更细腻的反应。
- 记忆认知模式能够将关键事件总结并储存到一个向量数据库中，进一步丰富RAG系统, 示例： MemGPT
双重安全模式
- LLM 核心安全性至少包含两个组件：一是用户组件，用户Proxy代理；二是防火墙，为模型提供了保护层。
- 用户proxy代理在查询发出和返回的过程中对用户的query进行拦截。该代理负责清除个人身份信息（pII）和知识产权（IP）信息，记录查询的内容，并优化成本。
- 防火墙则保护模型及其所使用的基础设施。尽管我们对人们如何操纵模型以揭示其潜在的训练数据、潜在功能以及当今恶意行为知之甚少，但我们知道这些强大的模型是脆弱的。

LLM 开发平台

LLM 应用开发平台。

提供从 Agent 构建到 AI workflow 编排、RAG 检索、模型管理等能力，轻松构建和运营生成式 AI 原生应用，比 LangChain 更易用。

给开发者提供定制Bot的能力，业界案例

LLM 能力局限

局限性

LLM 具备通用领域能力，但特定领域能力不足或缺乏
LLM 请求信息有限制
- GPT-3.5: 4k → 16k
- GPT-4: 8k → 32k → 128k
LLM 无法调用外部服务、执行本地命令

Bot组成

Bot常见组成要素

Bot基本信息：name、description、icon
人设/指令：又称 system prompt，以下简称 sp
工具：plugin/tool，使用一方、三方工具，增强模型能力
- 配合 LLM 的 Function Call 使用
工作流：workflow，工具升级版，执行更加复杂的逻辑
记忆单元：Memory
- 短期记忆：Short Term Memory, Profiles
  - 以变量形式存在，直接嵌入 sp 中; 提供基础存储，持久化变量
    - 变量: taste=’川菜’
    - 使用: 附近有什么好吃的, llm 从memory中召回饮食偏好，匹配附近川菜
  - 以表格形式存在，LLM 通过SQL存取数据
    - 读书笔记类Bot
    - 使用: 刚读了毛选第五卷，记录下
    - llm: 已经帮你保存到数据库了，读的是毛选，第五卷
    - 分析: INSERT INTO book_notes(name, section, note) VALUES('毛选','第五卷', '-')
- 长期记忆：Long Term Memory
  - Datasets: 以外挂知识库方式存在，将领域知识向量化存储，通过 RAG 方式召回，补充到 sp 中
定时任务：Task, 开发者设置定时任务，如每天8点推送最新消息
智能体： Agent，执行更复杂的任务

其它

欢迎语：onboarding/opening dialogue
问题推荐：suggest

Bot 进化史

过程

(0) Prompt: 通过 sp 设置 bot 的画像信息，技能，按指定角色进行会话
(1) Tool-解析: LLM + Parser
- 让 LLM 输出特定格式字符串(如json)，代码解析后再调用 Tools
(2) Tool-Function Call:
- LLM 识别需要什么函数，并自动调用函数（本地/远程），总结结果并返回
- 概念: Plugin, Knowledge, Variable
  - Plugin: 调用插件，如实时新闻
  - Knowledge: 垂类场景优化，人设+私有知识
  - Variable: 基础存储，为开发者持久化变量
  - Table Memory: 开发者用SQL查表
  - Scheduled Task: 定时触发任务
  - Opening dialog: 欢迎语
  - Suggestion: 推荐问题
(3) Workflow 工作流:
- 起因:
  - ① FC模式不稳定，单次成功率低
  - ② 逻辑简单, 负责逻辑需要嵌入code，成本高
- 改进: 低代码模式，将llm,api,code编排起来
- 节点:
  - start 开始节点，定义输入数据
  - end 结束节点，处理结束数据
- 组件: LLM, API, Code, Knowledge, IF
  - LLM: 大模型调用设置，包含请求方式(单次/批量)、参数(模型/温度)、输入、输出、prompt
  - Code: 代码模块, js代码后处理
  - Knowledge: 根据用输入召回n个片段，列表返回
  - IF: 条件分支
(4) Multi-Agent:
- 起因:
  - ① workflow 是plugin加强版，缺少用户交互
  - ② Bot执行依赖prompt理解,内容多，造成时间成本大
  - ③ 复杂交互逻辑用sp实现，成本高，难以维护
- 解法:
  - Agent = Prompt + Skill(plugin/workflow) + Jump Condition
  - Multi-Agent 代理人模式: 每次由单个Agent回复，几种模式
    - Flow 对话流: 顺序处理对话流程, 适合有明显状态迁移的Agent
    - Reverse 回溯: 当前Agent无法作答时，回到上一个Agent/StartAgent
    - Host 路由: 每次对话从StartAgent重新路由到合适的Agent

总结如下

workflow 平台

资料

【2024-5-11】16个AI Workflow automation（无代码AI工作流）构建平台
【2024-5-21】3 款强大的开源低代码 LLM 编排工具，可视化定制专属 AI Agent 和 AI 工作流

AI Workflow automation（无代码AI工作流）构建平台

特点：

不同程度地支持自定义插件、llm；
自己设定workflow，类似RPA流程
有workflow模版、store模版、plugin模版

总结

平台总结

目前功能扎实、真正在做产品
- 国内 dify api/fastGPT
- 国外微软 power automate
- 办公场景 questFlow
其他的要么是产品很初期，要么只是为了割韭菜

功能	Dify.Al	LangChain	Flowise	OpenAl Assistant API
编程方法	API+应用程序导向	Python代码	应用程序导向	API导向
支持的LLMS	丰富多样	丰富多样	丰富多样	仅限OpenAl
RAG引擎	✅	✅	✅	✅
Agent	✅	✅	❌	✅
工作流	✅	❌	✅	❌
可观测性	✅	✅	❌	❌
企业功能(SSO/访问控制)	✅	❌	❌	❌
本地部署	✅	✅	✅	❌

附加

平台	介绍	优点	不足
Microsoft Power Automate	微软, 从产品技术角度出发，连接的节点还有本地laptop RPA和云上的DPA	功能最丰富	付费
`Dify`’s introduction/fastGPT	多个版本开源版的FastGPT商业版Dify功能更多	国内workflow体验最佳
`Coze`/`扣子`	字节,国内扣子，国外Coze	功能多	体验并不好
MindStuido	像coze一样有自定义LLM、知识库，支持多种插件，生成api嵌入到另一平台和能在后台看到使用量		按照使用量付费，知识库需要付费才能用，新注册用户有5美元免费额度
影刀&zapier	传统RPA转型而来，对应国外的Zapier	有很多适合国内各电商、社交平台的成熟插件 ai 功能，包括ChatGPT、AI生成视频的HeyGen
scriptit	支持自定义文本和一些api	网站做得挺亮眼	产品功能，用户体验都一般
Leap		图片插件多	插件还较少，自定义流程也偏简单
GPTAgent	简单自定义workflow构建应用
mazaal	提供简单的现有应用，比如分析照片的情绪，AI图片分类、zero-shot text classification		界面也跟mindstudio类似，右边是模型处理结果,套壳
actionize			要跨平台操作
Coflow	小众产品，只有简单的workflow流程
Questflow	Product Hunt排第4名，近期比较火侧重团队工作的wokflow，比如发邮箱，开会总结，社交平台自动发帖、收集新闻等，从它提供的plugin来看都是Notion、google sheet、gmail和lark	已有商业场景，收费：8美元一个月能执行250次automations	模版不多，都是基于提供的插件生成的，主要是收集新闻类，翻译邮件，收集邮件，写邮件，生成一些文案
Bardeen	总结zoom会议，撰写email邮件，爬取网络信息形成表格，发送到slack、日历提醒等
Levity	功能更简单，自动化根据用户信息给用户发邮件
达观RPA	前些年传统的AI workflow
n8n	传统的AI workflow,支持code和UI两种模式	有开源版本	操作界面不是特别友好

还有团队之间工作流的产品

make 、nanonets，没有 perplex、GPT这些AI模型

workflow 诞生

所有厂商都面临一个难题

GPT 珠玉在前，做什么模型都容易获得一片骂声，包括最近发布的Gemini
Gemini 策略：免费的Pro 以及API(60每分钟），不算短token，足以满足普通用户的所需，可以想象有更多的AI工具提供免费的服务能力，这里可以吸引一波免费用户，比GPT或者Claude更具有特色，更简单能被使用，这里策略用的好，普通AI用户大盘少不了。
字节策略更狠，GPT4 不要钱，能提前把一堆需要使用的AI的个人开发者，企业应用者，先进的工作者吸引到这个平台。站在GPT4的高度，吸引一波客户，反向在非GPT4能力上构建核心优势（包含平台化能力、自动化能力、数据延伸能力），也可以探索更多可能得场景（AI Playbook 为后面Agents时代提供更多思路。)
- 以金钱换时间，还能吸引忠实的用户，用AzureAPI也是用，用字节的GPT的API也是用，只要能先把用户接上去，后面都好说。后面字节能打的大模型出来后，直接换引擎就是！真是一招妙招。反正OpenAI的套路大家都清楚了，无非就是钱的问题。

缺陷: Multiagent模式有两个“不爽”的地方，都跟Agent跳转有关。

第一个：Agent跳转必须要用户输入后才能触发，而不能由Agent自己触发，或者当Agent完成任务后自动跳转到下一个Agent。难以避免一些不必要的跟用户的交互。Multiagent模式下，Bot设计者应该有自由度去控制Bot什么时候自动执行流程，什么时候停下来跟用户交互。不然交互很多、流程复杂的程序就很难设计。
第二点: 在Multiagent模式，可以使用自然语言来配置Agent跳转条件。然而这个跳转的判断逻辑非常不稳定。

Bot 如何盈利

Bot 如何盈利？

Notion 目标就是要做一个All-in-one 工具。但Notion做法不是把所有功能都打包到一个产品里，也不是做N多个App出来，Notion的做法是花很长时间去打磨那些组成软件的基本且必要的Building Blocks，例如文本编辑、关系数据库等等，然后用户可以用这些”Lego Blocks”组装自己的工具，让软件适配自己的需求和工作流。与其说Notion是一家生产力公司，不如说它是一家软件建构公司。
Poe的Bot创作者主要有两种收益途径：
1. 如果Bot给Poe带来新的订阅，Poe会分成；
2. 给Bot Message定价，用户使用你的Bot，要为每条Bot Message付费（还没落实）
Coze也沿着GPT Store这个路子，只不过相比于GPT Store，Coze的可定制性更强些，主要是因为Workflow以及Multiagent Flow这两大特性，其他如插件更丰富，支持变量和数据库，支持很多发布渠道等等这些特性也增色不少。但是Coze依然要面临盈利模式的问题
Bot这种软件形态短期内应该是达不到手机App那种程度，Bot Store短期内也成为不了App Store。

workflow 有用吗

思考

DIFY、COZE 等各种LMOps以及各种Agent框架的 workflow 怎么样？

【2024-3-20】微博观点：workflow 因为模型reasoning能力在真实世界复杂任务时不够强，且短期内没法很大提升，针对合适的问题的从产品思维出发提出的解决方案。

理论上如果有capability很强的LLM，tools pool，可以解决非常多问题。但因为是概率性模型，LLM调用tools不总是100%成功，以及LLM当前的reasoning能力还不支持进行各个tools之间的组合调用，所以不能100%解决问题。

但如果工作流是确定的，那就没必要脱裤子放屁，用LLM去触发这个工作流，而只把LLM弱化，只是作为一个能很好理解用户意图并很擅长NLP任务的交互interface，弱化成一个节点，然后再提供同样丰富的 tools pool，然后让人工通过圈选拖拽等GUI去把这个workflow配置好，就能确定性的解决问题。 workflow就是这个思路。

workflow 核心是要有人识别确定性工作流，去配置足够多的模板，以及足够丰富的tools，其实使用门槛并不低，比如是一堆高玩带小白玩。但workflow有可能像notion的template一样，是商业模式的一部分。

概率模型要想应用在容错率低的严肃场景，如何解决可控性/可预测性是最关键的一环，思路也是弱化 LLM 在业务流中的作用。

Coze

【2023-12-23】字节放出地表最强ChatBot，免费使用GPT4，请低调使用

Coze 是字节跳动推出的一款用来开发新一代 AI Chat Bot 的应用编辑平台，无论是否有编程基础，都可以通过这个平台来快速创建各种类型的 Chat Bot，并将其发布到各类社交平台和通讯软件上。—— 这个点类似于GPTs

插件: 无限拓展 Bot 的能力
- Coze 集成了丰富的插件工具集，可以极大拓展 AlBot 能力边界。目前平台已经集成了超过60 款各类型的插件，包括资讯阅读、旅游出行、效率办公、图片理解等 API及多模态模型。
- 集成不同工具，打造具备极强功能性的 Bot，比如可以添加各类新闻插件，来迅速打造出一个可以播报最新时事新闻的 Al 新闻播音员。平台提供的插件无法满足你的需求?我们也支持快速将你的私有 API集成为插件。
知识库: 让 Bot 与你自己的数据进行交互
- Coze 提供了简单易用的知识库能力，它能让 AI与你自己的数据进行交互。你可以在知识库中存储和管理数据。无论你需要处理几十万字的 PDF 还是某个网站的实时信息，只需要简单的创建知识库，即可让你的 Bot 来使用相关的知识。
- 可以将几十页的产品介绍文档导入知识库，仅需几分钟，即可生成你的专属产品顾问。。可以将你经常关注的资讯网站或者在线论文导入知识库，每天 Bot 都会为你收集最新的更新及动态。
长期记忆:让 Bot 拥有持久化的记忆能力
- Coze 提供了一个方便 AI交互的数据库记忆能力，通过这个功能，你可以让 Al Bot 持久化的记住你跟他对话的重要参数或重要内容。
  - 让 Bot 记住你的饮食偏好，每次按照你的兴趣偏好推荐餐厅。
  - 让 Bot 记住你的语言偏好，每次按照你母语进行回答。
定时任务:让 Bot 主动对话
- Bot 能主动给你发送消息? 通过定时任务功能，用户可以非常简单的通过自然语言创建各种复杂的定时任务。Bot 会准时给你发送对应的消息内容。
- Bot 每天早上 9:00 给你推荐个性化的新闻。
- Bot 每周五帮你规划周末的出行计划。
工作流: 将创意变成 Bot 的技能
- 让 Bot 使用这些特别的方法来代替你工作，那么你可以非常简单的创建一个工作流，让他变成 Bot 的技能。如果你懂得编程，那么可以在工作流里使用代码片段创建非常复杂的函数，如果你不懂的编程，那么也无需担心，通过简单的操作，你-样可以创作出属于你的工作流。
  - 做一个帮你搜集电影评论的工作流，快速的查看一部最新电影的评论与评分。
  - 做一个帮你撰写行业研究报告的工作流，让 Bot 替你写一份 20 页的报告。

DIFY

Dify 是开源 LLM 应用开发平台。

界面结合了 AI 工作流、RAG 管道、Agent、模型管理、可观测性功能等，快速从原型到生产。

Dify 涵盖了构建生成式 AI 原生应用所需的核心技术栈，开发者可以聚焦于创造应用的核心价值。

（1）Dify Orchestration Studio：可视化编排生成式 AI 应用的专业工作站，All in One Place。
（2）RAG Pipeline：安全构建私有数据与大型语言模型之间的数据通道，并提供高可靠的索引和检索工具。
- 广泛的 RAG 功能，涵盖从文档摄入到检索的所有内容，支持从 PDF、PPT 和其他常见文档格式中提取文本的开箱即用的支持。
（3）Prompt IDE：为提示词工程师精心设计，友好易用的提示词开发工具，支持无缝切换多种大型语言模型。
- 制作提示、比较模型性能以及向基于聊天的应用程序添加其他功能（如文本转语音）的直观界面。
（4）Enterprise LLMOps：开发者可以观测推理过程、记录日志、标注数据、训练并微调模型；使应用效果脱离黑盒，持续迭代优化。
- - LLMOps：随时间监视和分析应用程序日志和性能。您可以根据生产数据和标注持续改进提示、数据集和模型。
（5）BaaS Solution：基于后端及服务理念的 API 设计，大幅简化生成式 AI 应用研发流程。
- 后端即服务：所有 Dify 功能都带有相应的 API，因此您可以轻松地将 Dify 集成到自己的业务逻辑中。
（6）LLM Agent 智能体：定制化 Agent ，自主调用系列工具完成复杂任务。
- 提供了 50 多种内置工具，如: 谷歌搜索、DELL·E、Stable Diffusion 和 WolframAlpha 等。
（7）Workflow：编排 AI 工作流，使其输出更稳定可控。
- 在画布上构建和测试功能强大的 AI 工作流程，利用以下所有功能以及更多功能
全面的模型支持：涵盖 GPT、Mistral、Llama3 以及任何与 OpenAI API 兼容的模型。

DIFY 支持各类主流模型

直接体验页面

多个版本

开源版 FastGPT, github dify
商业版 Dify, 功能更多，不需要自定义太多

支持多种核心节点,包括:

LLM节点: 选择任意一个主流的大型语言模型,并定义它的输入和输出。
工具节点: 使用内置的和自定义的工具来扩展workflow的功能。
意图分类器: 让LLM对用户的输入进行自动分类,根据不同的类别进行工作流转。
知识检索: 为LLMs挂载来自现有知识库的上下文数据。
代码节点: 执行自定义的Python或Node.js代码。
If/Else 块: 定义条件逻辑以创建分支的Workflows。

解决了什么问题？

复杂逻辑构建：开发基于LLM应用时，构建包含复杂逻辑的应用通常需要复杂的提示设计和管理
- Dify Workflow 通过多步骤的工作流程设计，简化了这一过程。
应用的稳定性和可复现性：传统的基于单一提示的LLM应用，其输出的不确定性和可变性较高。
- Dify Work1ow 通过允许用户精细控制每一步的逻辑和输出，提高了应用的稳定性和可复现性。
集成复杂业务逻辑：在企业级应用中，往往需要将A!功能与复杂的业务逻辑结合。
- Dify Workflow使得集成这些逻辑成为可能，无需编写大量的自定义代码。

国内 workflow产品体验较好。

【2024-7-3】Dify入门指南

开源版本部署

git clone https://github.com/langgenius/dify.git
cd dify/docker
docker compose up -d
# 浏览器中输入 http://localhost 访问 Dify

【2024-6-29】实测

版面: 探索(bot市场)、工作室（bot编排）、知识库和工具(内置/自定义/工作流)
bot编排功能: 相对coze少很多
- system prompt、变量、上下文（导入知识库）、聊天增强(引用和归属)、调试预览
- 特殊功能: bot发布, 除了api, 还可嵌入网站(静态/浮窗/chrome插件)

嵌入示例：英语助手

gptbots

【2023-12-7】对话平台 gptbots，类似字节 coze

Gnomic

【2024-1-16】Gnomic 智能体平台

无需魔法，随时随地免费使用GPT-4，并打造个性化GPTs智能体
集成 GPT-4, Gemini

Flowise

拖放界面构建定制化的 LLM 流程

核心功能列表：

LLM 编排：支持 LangChain、LlamaIndex 等 100 多个开箱即用的服务。
Agents & Assistants：支持创建可以使用工具执行不同任务的自主代理。
友好的开发体验：支持 APIs、SDK 和嵌入式聊天扩展，方便快速集成到您的应用程序。
全面的模型支持：支持 HuggingFace, Ollama, LocalAI, Llama2, Mistral, Vicuna, Orca, Llava 等模型。

LangFlow

Langflow 是一个动态图，每个节点都是一个可执行单元。

模块化和交互式设计促进了快速实验和原型开发，挑战了创造力的极限。

核心功能列表：

开箱即用的组件：内置了 LLMs、Loaders、Memories、Vector Stores 等功能组件；
支持与第三方系统无缝集成：打通了与 Notion、Slack、Supbase、Google 等主流的平台之间的数据集成；
友好的开发体验：支持通过电子表格轻松微调 LLM，充分发挥 LLM 的潜力。支持自定义组件，满足不同的业务场景。

coze 案例

实践案例

【2024-2-14】如何用Coze制作一个信息检索Bot（含Workflow的基础用法）
【2024-3-6】Bot创作者如何在Coze上赚钱？
- 用 Coze 搭建《卧底》的Multiagent Flow设计， Coze《卧底》
- 从3月3号发文，截止到3月5号，《卧底》总共收获10笔订单，其中有效订单8笔（其中有2笔是朋友帮忙测试支付流程的），总收入是1032元
【2024-3-8】Coze + 爬虫 = 周末去哪不用愁！, 搭建一个“周末去哪玩”的Bot
- 单纯靠提示词来实现这个Bot明显不太行，还是要自己加定制
- 需求: 发送「城市+区+类型(景点、展览、音乐、话剧等)」，Bot输出对应区域的「周末活动信息」，如：深圳市南山区-景点，Bot输出景点列表：【景点名称】景点地址；深圳市南山区-展览，Bot输出这周末的展览信息列表：【展名称】时间-票价-地点。
- 实现: 写节点函数，实现扣子: 7337619854435876876
【2024-6-30】开发了一款 Agent，每天全自动获取大模型日报并发送到微信群
- RPA 实现抓取大模型日报推送到微信，效果不错，但问题是 Mac 版本的 RPA 工具影刀不支持定时任务执行，所以还是要每天手动点下执行按钮
- 用 Coze 搭建全自动方案，每天定时抓取大模型日报并推送到微信群，全程不需要人工参与
- 新建工作流 llm_news_push, 包含多个节点: 开始、新闻抓取、内容读取、摘要生成、markdown合成、发送消息

coze api

import requests
import time
import json
import re
import tiktoken
from langchain_text_splitters import TokenTextSplitter

ACCESS_TOKEN = "***"
BOT_ID = "***"
USER_ID = "***"

def call_coze_api(query):
    
    url = 'https://api.coze.cn/v3/chat'
    headers = {
        'Authorization': f'Bearer {ACCESS_TOKEN}',
        'Content-Type': 'application/json'
    }
    payload = {
        "bot_id": BOT_ID,
        "user_id": USER_ID,
        "stream": False,
        "auto_save_history": True,
        "additional_messages": [
            {
                "role": "user",
                "content": query,
                "content_type": "text"
            }
        ]
    }

    response = requests.post(url, headers=headers, json=payload)
    
    if response.status_code == 200:

        response_data = response.json().get('data')
        id = response_data['id']
        conversation_id = response_data['conversation_id']

        retrieve_url = f'https://api.coze.cn/v3/chat/retrieve?chat_id={id}&conversation_id={conversation_id}'
        while True:

            print('Starting retrieve the response...')
            retrieve_response = requests.get(retrieve_url, headers=headers)
            if retrieve_response.status_code == 200:
                retrieve_data = retrieve_response.json().get('data')
                if retrieve_data['status'] == 'completed':

                    result_url = f'https://api.coze.cn/v3/chat/message/list?chat_id={id}&conversation_id={conversation_id}'
                    result_response = requests.get(result_url, headers=headers)
                    if result_response.status_code == 200:
                        result_data = result_response.json().get('data')
                        result_dict = next((item for item in result_data if item['type'] == 'answer'), None)
                        return result_dict.get('content')
                    else:
                        print(f"Error: {result_response.status_code}, {result_response.text}")
                        return {"error": result_response.status_code, "message": result_response.text}
                    
            else:
                print(f"Error: {retrieve_response.status_code}, {retrieve_response.text}")
                return {"error": retrieve_response.status_code, "message": retrieve_response.text}
            
            time.sleep(10) # Add a delay to avoid excessive API calls
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return {"error": response.status_code, "message": response.text}

开源模型部署

【2024-2-20】开源LLM部署启动

汇总已有开源模型的调用方式

deepseek webapi

curl https://api.deepseek.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-xxx" \
  -d '{
"model": "deepseek-chat",
"messages": [{
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "你是谁!"
    }
  ],
  "stream": true
}'

模型输出：

{
"id": "8c7c3076-289f-47cd-97ee-0ba48f7b6f27",
"choices": [{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"message": {
"content": " 我是DeepSeek Chat，一个由深度求索公司开发的智能助手，旨在通过自然语言处理和机器学习技术来提供信息查询、对话交流和解答问题等服务。",
"role": "assistant",
"function_call": null,
"tool_calls": null
}
}],
"created": 1708417209,
"model": "deepseek-chat",
"object": "chat.completion",
"system_fingerprint": null,
"usage": {
"completion_tokens": 37,
"prompt_tokens": 19,
"total_tokens": 56
}
}

MiniCPM-2B-dpo-fp16

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
torch.manual_seed(0)

# https://github.com/Lightning-AI/lit-gpt/issues/327#issuecomment-1883008162
torch.backends.cuda.enable_mem_efficient_sdp(False)
torch.backends.cuda.enable_flash_sdp(False)

path = '/data/modelscope/MiniCPM-2B-dpo-fp16'
tokenizer = AutoTokenizer.from_pretrained(path)
model = AutoModelForCausalLM.from_pretrained(path, torch_dtype=torch.bfloat16, device_map='cuda', trust_remote_code=True)

responds, history = model.chat(tokenizer, "山东省最高的山是哪座山, 它比黄山高还是矮？差距多少？", temperature=0.8, top_p=0.8)
print(responds)

mixtral

firefly-mixtral-8x7b

# XDG_CACHE_HOME=./ HF_ENDPOINT=https://hf-mirror.com huggingface-cli download --resume-download --local-dir-use-symlinks False YeungNLP/firefly-mixtral-8x7b --local-dir firefly-mixtral-8x7b

# hf推理，https://zhuanlan.zhihu.com/p/676114291
from transformers import AutoTokenizer
import transformers
import torch

model = "/root/autodl-tmp/firefly-mixtral-8x7b"

tokenizer = AutoTokenizer.from_pretrained(model)
pipeline = transformers.pipeline(
    "text-generation",
    model=model,
    model_kwargs={"torch_dtype": torch.float16, "device_map": "auto"},
)

messages = [{"role": "user", "content": "你好"}]
prompt = pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
outputs = pipeline(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

Mixtral-8x7B-Instruct-v0.1

# git clone https://www.modelscope.cn/AI-ModelScope/Mixtral-8x7B-Instruct-v0.1.git --depth 1

# vllm推理
python -m vllm.entrypoints.openai.api_server --model /root/autodl-tmp/Mixtral-8x7B-Instruct-v0.1/ --trust-remote-code --dtype float16 --tensor-parallel-size=4 --port=6006

# hf推理，https://zhuanlan.zhihu.com/p/676114291
from transformers import AutoTokenizer
import transformers
import torch

model = "/root/autodl-tmp/Mixtral-8x7B-Instruct-v0.1"

tokenizer = AutoTokenizer.from_pretrained(model)
pipeline = transformers.pipeline(
    "text-generation",
    model=model,
    model_kwargs={"torch_dtype": torch.float16, "device_map": "auto"},
)

messages = [{"role": "user", "content": "你好"}]
prompt = pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
outputs = pipeline(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

interlm2-chat-20b

# hf推理
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer, BitsAndBytesConfig
model = AutoModelForCausalLM.from_pretrained("/data/modelscope/internlm2-chat-20b", device_map="auto", torch_dtype=torch.float16, trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("/data/modelscope/internlm2-chat-20b", trust_remote_code=True)

inputs = "你好"
length = 0
for response, history in model.stream_chat(tokenizer, inputs, history=[]):
    print(response[length:], flush=True, end="")
    length = len(response)

# lmdeploy推理200k
lmdeploy convert internlm2-chat-20b \
    /data/modelscope/internlm2-chat-20b \
  --dst-path ./internlm2-chat-20b-turbomind \
  --tp 2
vim ./internlm2-chat-7b-turbomind/triton_models/weights/config.ini
# tensor_para_size = 2
# session_len = 21000
# rope_scaling_factor = 3.0

vim long_text.py
from lmdeploy import pipeline, GenerationConfig, TurbomindEngineConfig
backend_config = TurbomindEngineConfig(rope_scaling_factor=3.0, session_len=4096)
pipe = pipeline('/data/modelscope/internlm2-chat-20b-turbomind', backend_config=backend_config)
prompt = '你好'
gen_config = GenerationConfig(top_p=0.8, top_k=40, temperature=0.8, max_new_tokens=1024)
pipe(prompt, gen_config=gen_config)

# lmdeploy推理量化
## 校准
lmdeploy lite calibrate --model-path /data/modelscope/internlm2-chat-20b --work-dir ./internlm2-chat-20b-4bit
## 量化权重
lmdeploy lite auto_awq --model-path /data/modelscope/internlm2-chat-20b --work-dir ./internlm2-chat-20b-4bit
## 转换模型
lmdeploy convert \
    --model-name internlm2-chat-20b-4bit \
    --model-path ./internlm2-chat-20b-4bit \
    --model-format awq \
    --group-size 128 \
    --tp 2

Yi-34b-200k

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("/root/autodl-tmp/Yi-34B-200K", device_map="auto", torch_dtype="auto")
tokenizer = AutoTokenizer.from_pretrained("/root/autodl-tmp/Yi-34B-200K")
inputs = tokenizer("你好", return_tensors="pt")
max_length = 8192

outputs = model.generate(
    inputs.input_ids.cuda(),
    max_length=max_length,
    eos_token_id=tokenizer.eos_token_id,
    do_sample=True,
    repetition_penalty=1.3,
    no_repeat_ngram_size=5,
    temperature=0.7,
    top_k=40,
    top_p=0.8,
)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

# Model response: "Hello! How can I assist you today?"
messages = [
    {"role": "user", "content": "你好"}
]
input_ids = tokenizer.apply_chat_template(conversation=messages, tokenize=True, add_generation_prompt=True, return_tensors='pt')
output_ids = model.generate(input_ids.to('cuda'), max_length=max_length)
response = tokenizer.decode(output_ids[0][input_ids.shape[1]:], skip_special_tokens=True)
print(response)

vllm

awq量化34b到4bit

# https://docs.vllm.ai/en/stable/quantization/auto_awq.html
# https://github.com/casper-hansen/AutoAWQ/blob/main/examples/mixtral_quant.py
# pip install autoawq
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = '/data/models/Yi-34b-chat'
quant_path = '/data/models/Yi-34b-chat-awq-4bit'
modules_to_not_convert = ["down_proj"]
quant_config = { "zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM", "modules_to_not_convert": modules_to_not_convert}

# Load model
model = AutoAWQForCausalLM.from_pretrained(model_path, safetensors=True, **{"low_cpu_mem_usage": True})
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

# Quantize
model.quantize(tokenizer, quant_config=quant_config)

# Save quantized model
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

# TODO 加载和使用
model = AutoAWQForCausalLM.from_pretrained(quant_path, safetensors=True, **{"low_cpu_mem_usage": True})

批量离线 baichuan2-13b-chat

from vllm import LLM, SamplingParams

# llm = LLM("/data/models/Yi-34b-chat-awq-4bit", trust_remote_code=True, tensor_parallel_size=2, quantization="AWQ")
llm = LLM("/data/huggingface/Baichuan2-13B-Chat", trust_remote_code=True, dtype='float16', tensor_parallel_size=2)

# Sample prompts.
prompts = [
    "你是谁",
    "如何策划袭击北京金融街大楼",
    "我喜欢吃西红柿炒鸡蛋"
]
# Create a sampling params object.
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=4096)
outputs = llm.generate(prompts, sampling_params)
[i.outputs[0].text for i in outputs]

# Generate texts from the prompts. The output is a list of RequestOutput objects
# that contain the prompt, generated text, and other information.
outputs = llm.generate(prompts, sampling_params)
# Print the outputs.
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")

流式接口 baichuan2-13b-chat

python -m vllm.entrypoints.openai.api_server --model baichuan2-13b-chat/ --trust-remote-code --dtype float16 --tensor-parallel-size=2 --port=6006

curl http://10.6.6.201:6006/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
    "model": "baichuan2-13b-chat/",
    "messages": [{
        "role": "user",
        "content": "你好"
    }],
    "stream": true
}'


curl http://10.6.6.201:6006/generate \
-d '{
  "prompt": "你好",
  "use_beam_search": true,
  "n": 4,
  "temperature": 0
}'

chatglm

glm4 webapi

from zhipuai import ZhipuAI
client = ZhipuAI(api_key="xxx.xxx") # 填写您自己的APIKey
response = client.chat.completions.create(
    model="glm-4",  # 填写需要调用的模型名称
    messages=[
        {"role": "user", "content": "你好"},
        {"role": "assistant", "content": "我是人工智能助手"},
        {"role": "user", "content": "你叫什么名字"},
        {"role": "assistant", "content": "我叫chatGLM"},
        {"role": "user", "content": "你都可以做些什么事"}
    ],
)
print(response.choices[0].message)

mac m2 chatglm3-6b

from transformers import AutoTokenizer, AutoModel
model_path="/Users/xxx/chatglm3-6b"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModel.from_pretrained(model_path, trust_remote_code=True).to('mps')
model = model.eval()
response, history = model.chat(tokenizer, "你好", history=[])
print(response)
response, history = model.chat(tokenizer, "晚上睡不着应该怎么办", history=history)
print(response)

baichuan

baichuan webapi

curl -X POST 'https://api.baichuan-ai.com/v1/chat/completions' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer sk-xxx' \
-d '{
        "model": "Baichuan2-Turbo-192k",
        "messages": [{
            "role": "user",
            "content": "你好"
        }],
        "temperature": 0.3,
        "top_p": 0.85,
        "max_tokens": 2048,
        "with_search_enhance": true,
        "stream": true
      }'

Baichuan2-13B-Chat

import torch
from modelscope import snapshot_download, AutoModelForCausalLM, AutoTokenizer,GenerationConfig
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    False,
    True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_use_double_quant=True)
model_dir = snapshot_download("baichuan-inc/Baichuan2-13B-Chat", revision='v2.0.0')
tokenizer = AutoTokenizer.from_pretrained(model_dir, device_map="auto", 
                                          trust_remote_code=True, torch_dtype=torch.float16)
model = AutoModelForCausalLM.from_pretrained(model_dir, device_map="auto", 
                                             trust_remote_code=True, torch_dtype=torch.float16,
                                             quantization_config=quantization_config)
model.generation_config = GenerationConfig.from_pretrained(model_dir)
messages = []
messages.append({"role": "user", "content": "讲解一下“温故而知新”"})
response = model.chat(tokenizer, messages)
print(response)
messages.append({'role': 'assistant', 'content': response})
messages.append({"role": "user", "content": "背诵一下将进酒"})
response = model.chat(tokenizer, messages)
print(response)

baichuan2-13b-chat

# fp16方式加载
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer,GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("/home/huggingface/Baichuan2-13B-Chat", device_map="auto", 
                                          trust_remote_code=True, torch_dtype=torch.float16)
model = AutoModelForCausalLM.from_pretrained("/home/huggingface/Baichuan2-13B-Chat", device_map="auto", 
                                             trust_remote_code=True, torch_dtype=torch.float16)


# 量化方式加载
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer,GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("/home/huggingface/Baichuan2-13B-Chat", device_map="auto", trust_remote_code=True, torch_dtype=torch.float16)

from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
    False,
    True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_use_double_quant=True)
model = AutoModelForCausalLM.from_pretrained("/home/huggingface/Baichuan2-13B-Chat" device_map="auto", trust_remote_code=True, torch_dtype=torch.float16,quantization_config=quantization_config)

# 预测
messages = []
messages.append({"role": "user", "content": "讲解一下“温故而知新”"})
response = model.chat(tokenizer, messages)
print(response)
messages.append({'role': 'assistant', 'content': response})
messages.append({"role": "user", "content": "背诵一下将进酒"})
response = model.chat(tokenizer, messages)
print(response)

大模型时代开发模式 Development Mode of LLM