《实用笔记：构建个人智能体的分步指引》
《实用笔记操作指南：构建个人智能体的分步指引——适用于采用该模式的团队的合同、校验机制及即用代码模块》。
本指南将逐步展示如何从原始材料构建出一个可运行的系统，内容来自《个人智能体系统开发分步指南》。重点在于具体的操作步骤、明确的检查点，以及可直接放入代码仓库的代码，无需猜测其用途。
实践教程
在实践教程阶段，应在修改代码之前明确输入参数、各步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行相应步骤，而无需猜测隐藏状态。配置信息应与应用程序代码分开存放，环境文件、密钥存储和功能开关应集中管理，以便操作人员无需查看整个系统结构即可进行审核。对于涉及资金支出或修改生产数据的操作，需经过人工审批；仅靠编译时的配置并不足以确保业务的完整性。
如何搭建并创建属于自己的代理型大语言模型系统的全指南：结合本地数据库，针对特定任务进行优化。
在修改代码之前，需先制定完整的流程指南，明确输入内容、各步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行相应步骤，而无需猜测隐藏状态。同时需记录正常流程与异常恢复路径；重试机制、人工审核环节以及错误处理都是产品不可或缺的部分，而非后续需要补充的功能。当下一步操作为编写代码或调用工具时，应优先使用具有结构化格式且经过模式验证的输出，而非自由形式的文字描述。
代理型系统简介。
在进入“代理化入门”阶段时，应在修改代码之前明确输入内容、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比冗长的脚本，更应优先使用小型且可测试的单元。当某个步骤失败时，故障原因应能指向单一责任点，而非复杂的流程链。对于涉及资金支出或修改生产数据的操作，必须经过人工审批。编译时的连接方式并不等同于业务功能的完整性。
要点1：你的大型语言模型不是写作工具，而是CPU。
对于第一个要点“你的大语言模型阶段”，在修改代码之前需明确输入内容、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。应将此阶段视为输入与经过验证的输出之间的契约：为生成的结果命名，定义成功判定标准，并拒绝默许的半完成状态。当下一步是编写代码或调用工具时，优先选择具有结构化格式且经过模式验证的输出，而非自由形式的文字描述。
第二个要点：你不需要数十亿个参数，而是需要一支专业的“智能代理团队”。
在“Takeaway 2 You Don”阶段，修改代码之前需明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 在功能结果旁记录执行时间以及令牌或查询成本。提前显示成本可避免在流程从演示环境转向共享环境时出现意外费用。 对于会消耗资金或修改生产数据的操作，必须经过人工审批。编译时的配置并不等同于业务功能的完整性。 在“Takeaway 2 You Don”阶段，修改代码之前需明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 需同时记录正常流程和异常恢复流程。重试机制、人工审核环节以及错误处理都是产品不可或缺的部分，而非后续需要补充的内容。
现实世界的问题：人类与机器的较量。
在处理“现实世界问题——人类阶段”时，首先写下相关契约：所需的输入、成功信号以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 优先选择小型、可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应指向单一责任点，而非复杂的流程链。 在成本较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次调用相同的大型语言模型。
为何单一提示词会失败，而智能体系统却能成功。
在处理“为何单一提示会失败”这一阶段时，首先需写下相关契约：所需输入、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 将这一阶段视为输入与验证后输出之间的契约。为相关成果命名，明确成功判定标准，并杜绝无声的半完成状态。 缓存稳定的系统指令和工具架构。重复发送相同的开头信息是导致资源浪费的常见原因。
什么是智能体架构？
在完成“什么是智能体”这一阶段时，首先需写下相关规范：所需的输入参数、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 在功能结果旁记录执行时间以及令牌或查询成本。提前明确成本信息，可避免在从演示环境过渡到共享环境时出现意外费用。 在耗时较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次调用相同的大型语言模型。 在完成“什么是智能体”这一阶段时，首先需写下相关规范：所需的输入参数、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 需同时记录正常流程与异常恢复流程。重试机制、人工审核环节以及死信处理都是产品功能的一部分，而非后续需要补充的内容。
检索增强生成（RAG）流程。
将检索增强生成RAG流程视为可度量的对象时，其效果最佳。在扩大范围之前，先记录一份理想的处理结果、一个失败案例以及回滚说明。 相较于庞大的脚本，应优先选择小型且易于测试的单元。当某个步骤出现故障时，故障原因应能明确指向具体的责任模块，而非整个复杂的流程。 应将分块策略与检索策略分开。当质量指标发生变化时，修改其中一项不应迫使重新编写另一项。
RAG系统面临的挑战
RAG阶段所面临的挑战，若将其视为可测量的对象来处理会更为有效。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。 将这一阶段视为输入与经过验证的输出之间的契约。为相关成果命名，明确成功标准，绝不允许出现无声无息的半完成状态。 将分块策略与检索策略分开。当质量指标发生变化时，修改其中一项不应迫使重新编写另一项。
RAG流程需要四个步骤
这四个步骤是必需的阶段性工作，若将其视为可度量的指标则效果最佳。在扩大范围之前，需记录一份理想的处理结果、一个故障案例以及回滚说明。应在功能结果旁同时记录处理时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。应将分块策略与检索策略分开，当质量指标发生变化时，修改其中一项不应迫使重新编写另一项。这四个步骤是必需的阶段性工作，若将其视为可度量的指标则效果最佳。在扩大范围之前，需记录一份理想的处理结果、一个故障案例以及回滚说明。需将正常处理路径和恢复路径一并记录下来。重试机制、人工审核环节以及死信处理都属于产品本身的功能，而非后续需要补充的内容。
分块的排序与聚合
在实现阶段的排序与聚合功能时，应在修改代码之前明确输入参数、该步骤的负责人以及终止条件。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比冗长的脚本，更应采用小型且可测试的单元。当某个步骤失败时，故障原因应能明确指向某个具体的责任模块，而非整个复杂的流程。对于涉及资金支出或修改生产数据的操作，必须经过人工审批。仅靠编译时的配置并不能保证业务的完整性。
最后一步是生成。
在“最终步骤”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将此阶段视为输入与已验证输出之间的契约。为相关成果命名，定义成功检测标准，并拒绝默许的半完成状态。 对于涉及资金支出或修改生产数据的操作，必须经过人工审批。编译时的连接方式并不等同于业务上的完整性。
使用此流程能实现出色效果的任务。
在“表现卓越的任务”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 在功能结果旁记录执行时间以及令牌或查询成本。提前显示成本可避免在流程从演示环境转向共享环境时出现意外费用。 对于会耗费资金或修改生产数据的操作，必须经过人工审批。编译时的配置并不等同于业务功能的完整性。 在“表现卓越的任务”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 需同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理都是产品不可或缺的部分，而非后续需要补充的内容。
在处理全局推理工作流阶段时，首先需明确相关约定：所需的输入参数、成功标志，以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 建议采用小型、可测试的单元而非庞大的脚本。当某个步骤出现故障时，故障应指向单一责任模块，而非复杂的流程链。 应对稳定的系统指令和工具结构进行缓存。重复发送相同的开头信息是导致资源浪费的常见原因。
两步式全局推理策略
在处理“两步全局推理”阶段时，首先写下相关契约：所需的输入参数、成功标志，以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 将这一阶段视为输入与验证后输出之间的契约。为相关成果命名，明确成功判定标准，杜绝无声的半完成状态。 缓存稳定的系统指令和工具架构。重复发送相同的开头信息是导致资源浪费的常见原因。
查询重写
在处理查询重写阶段时，首先需明确相关规范：所需输入、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改保持一致性。 在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。 在耗时较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次调用相同的大型语言模型。 在处理查询重写阶段时，首先需明确相关规范：所需输入、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改保持一致性。 需同时记录正常流程与异常恢复流程。重试机制、人工审核环节以及死信处理都是产品功能的一部分，而非后续需要补充的内容。
本地推理与全局推理的结合
将“局部与全局推理”阶段视为可度量的对象来处理，效果最佳。在扩大范围之前，先记录一份优秀的测试案例、一个失败案例以及回滚说明。 相较于庞大的脚本，应优先选择小型且可测试的单元。当某一步骤失败时，故障应指向单一责任模块，而非复杂的流程链。 需为每轮及每次会话设定token预算。智能代理工具会大量消耗上下文资源，设置上限可避免演示过程变成意外的费用账单。
小型语言模型正在胜出。
将小型语言模型视为可测量的界面时，其在该阶段的表现最为出色。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。 把这一阶段视为输入与经过验证的输出之间的契约。为相关成果命名，明确成功标准，绝不允许出现无声无息的半完成状态。 为每轮对话和每次会话设定token预算。智能工具往往会过度扩展上下文；设置上限可避免演示过程变成意外的费用账单。
使用LM Studio搭建自己的本地模型。
将“自行设置阶段”视为可度量的测试环境使用效果最佳。在扩大范围之前，需记录一份理想的操作流程、一个故障案例以及回滚说明。 在功能测试结果旁同时记录执行时间以及令牌或查询成本。提前了解成本情况，可避免从演示环境过渡到共享环境时出现意外账单。 为每轮操作和每次会话设定令牌预算。智能工具往往会大量消耗上下文资源，设置上限能防止演示环境变成意外收费的源头。 将“自行设置阶段”视为可度量的测试环境使用效果最佳。在扩大范围之前，需记录一份理想的操作流程、一个故障案例以及回滚说明。 需同时记录正常流程与异常恢复流程。重试机制、人工审核环节以及死信处理都是产品功能的一部分，而非后续需要补充的内容。
LLMlight 库。
在LLMlight Library阶段，修改代码之前需先明确输入内容、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。相比冗长的脚本，更应采用小型、可测试的单元。当某个步骤失败时，故障原因应能指向单一责任主体，而非复杂的流程链。若后续步骤为代码或工具调用，相比自由形式的文字描述，结构化且经过模式验证的输出更为合适。
分块策略
在分块策略阶段，应在修改代码之前明确输入内容、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将此阶段视为输入与已验证输出之间的契约。为相关成果命名，定义成功判定标准，并拒绝默许的半完成状态。 对于涉及资金支出或修改生产数据的操作，必须经过人工审批。编译时的连接方式并不等同于业务上的完整性。
搜索策略 — 本地数据库。
在搜索策略本地数据库阶段，修改代码之前需明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 在功能结果旁记录执行时间以及令牌或查询成本。提前显示成本可避免在从演示环境过渡到共享环境时出现意外费用。 对于会产生费用或修改生产数据的操作，必须经过人工审批。编译时的配置并不等同于业务功能的完整性。 在搜索策略本地数据库阶段，修改代码之前需明确输入参数、该步骤的负责人以及终止标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 需同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品的一部分，而非事后才考虑的内容。
进行嵌入评分策略设计时，首先需明确相关约定：所需输入、成功标志以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。
嵌入与评分策略
与其编写庞大的脚本，不如选择小型且可测试的单元。当某个步骤出现故障时，故障应指向单一责任模块，而非复杂的流程链。
在调整提示词之前，先使用固定的问题集来衡量召回率。仅仅更换提示词往往无法解决检索效果不佳的问题。
上下文策略
在处理上下文策略阶段时，首先写下相关契约：所需的输入参数、成功标志以及部分失败时的处理方式。这样的清单能确保后续的代码修改保持一致性。 将此阶段视为输入与验证后输出之间的契约。为相关成果命名，明确成功判定标准，并杜绝无声的半完成状态。 在成本较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次调用相同的大型语言模型。
提示词优化
在进行提示词优化阶段时，首先需明确相关约定：所需输入、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改始终符合初始设计。
在记录功能结果的同时，还需标注执行时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。
应缓存稳定的系统指令和工具结构。重复发送相同的开头信息是导致资源浪费的常见原因。
在进行提示词优化阶段时，首先需明确相关约定：所需输入、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改始终符合初始设计。
需同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品不可或缺的部分，而非后续需要补充的内容。
练习1：加载单个模型并进行简单对话。
在将“练习1：加载A阶段”视为可度量的工作面时，其效果最佳。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。 相较于庞大的脚本，应优先选择小型且可测试的单元。当某一步骤失败时，故障应指向单一的责任主体，而非复杂的流程链。 需为每轮及每次会话设定令牌预算。智能工具会大量消耗上下文资源，设置上限可避免演示过程变成意外的费用账单。
# Install the library
pip install llmlight
from LLMlight import LLMlight
# Initialize the LLMlight client
client = LLMlight(model='google/gemma-4-26b-a4b-qat', endpoint="http://localhost:1234/v1/chat/completions")
# Ask a question
response = client.prompt('What is the capital of France?')
print(response)
# [LLMlight.LLM] [INFO ] Model : google/gemma-4-26b-a4b-qat
# [LLMlight.LLM] [INFO ] Context strategy : disabled
# [LLMlight.LLM] [INFO ] Retrieval method : naive_rag
# [LLMlight.LLM] [INFO ] Embedding : {'memory': 'bert', 'context': 'bert'}
# [LLMlight.LLM] [INFO ] Alpha (sig. test): None
# [LLMlight.LLM] [INFO ] Chunk config : {'method': 'chars', 'size': 1000, 'overlap': 200}
# [LLMlight.LLM] [INFO ] LLMlight initialised.
# [LLMlight.LLM] [INFO ] Creating response with google/gemma-4-26b-a4b-qat..
# [LLMlight.LLM] [INFO ] No context strategy applied.
# [LLMlight.LLM] [INFO ] No context is provided into the prompt.
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
# The capital of France is Paris.
练习2：创建本地知识库。
在“练习2：创建阶段”中，将其视为可度量的界面最为有效。在扩大范围之前，先记录一个成功的案例、一个失败案例以及回滚说明。 将此阶段视为输入与已验证输出之间的契约。为相关成果命名，明确成功标准，绝不允许默默地部分完成任务。 保持图表状态简洁且具有类型定义。嵌套的数据块会掩盖哪个节点修改了哪个字段的信息，还会在任务中断后导致无法继续处理。
# Import library
from LLMlight import LLMlight
# Initialize model and memory
client = LLMlight(model='google/gemma-4-26b-a4b-qat', endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Add a PDF file to the database (extracts and chunks text automatically)
url = 'https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf'
pdf_text = client.read_pdf(url)
# Write to db
client.memory_add(text=pdf_text)
# Show the chunks
client.memory_chunks(1)
# Store to disk (SQLite DB is persisted automatically)
client.memory_save()
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 3 sentences.')
print(response)
练习3：使用上下文策略方法时输出的差异。
在将“练习3：差异分析”阶段视为可度量的对象时，其效果最佳。在扩大范围之前，需记录一份理想状态下的操作日志、一个故障案例以及回滚说明。 在功能结果旁同时记录处理时间以及令牌或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外费用。 保持图表状态简洁且类型明确。嵌套的数据块会掩盖哪个节点修改了哪个字段的信息，还会在出现中断后导致流程无法继续。 在将“练习3：差异分析”阶段视为可度量的对象时，其效果最佳。在扩大范围之前，需记录一份理想状态下的操作日志、一个故障案例以及回滚说明。 需同时记录正常流程与恢复流程的相关文档。重试机制、人工审核环节以及死信处理都是产品本身的组成部分，而非后续需要补充的内容。
from LLMlight import LLMlight
# Initialize with NO context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy=None, top_chunks=6, endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
print(response)
# Based on the provided text, attention networks utilize mechanisms like self-attention
# to perform tasks such as reading comprehension, summarization, and machine translation
# by capturing the syntactic and semantic structures of sentences.
# They operate by computing attention weights on "values" using "queries" and "keys" through
# a softmax function, with common types being additive or dot-product multiplicative attention.
from LLMlight import LLMlight
# Initialize with CHUNK-WISE context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy='chunk-wise', top_chunks=6, endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
# [LLMlight.LLM] [INFO ] Chunk wise analysis on 6 chunks of text.
# Processing chunk: 0%| | 0/6 [00:00<?, ?chunk/s][08-06-2026 22:11:53] [LLMlight.LLM] [INFO ] Working on text chunk 1/6
# Processing chunk: 17%|█▋ | 1/6 [00:54<04:31, 54.24s/chunk][08-06-2026 22:12:47] [LLMlight.LLM] [INFO ] Working on text chunk 2/6
# Processing chunk: 33%|███▎ | 2/6 [01:18<02:26, 36.66s/chunk][08-06-2026 22:13:12] [LLMlight.LLM] [INFO ] Working on text chunk 3/6
# Processing chunk: 50%|█████ | 3/6 [01:30<01:15, 25.33s/chunk][08-06-2026 22:13:23] [LLMlight.LLM] [INFO ] Working on text chunk 4/6
# Processing chunk: 67%|██████▋ | 4/6 [01:51<00:47, 23.81s/chunk][08-06-2026 22:13:45] [LLMlight.LLM] [INFO ] Working on text chunk 5/6
# Processing chunk: 83%|████████▎ | 5/6 [02:47<00:35, 35.13s/chunk][08-06-2026 22:14:40] [LLMlight.LLM] [INFO ] Working on text chunk 6/6
# Processing chunk: 100%|██████████| 6/6 [03:14<00:00, 32.48s/chunk]
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
print(response)
# The provided context does not contain a formal definition of "attention networks."
# It only describes the mathematical mechanism of attention, which uses queries, keys, and values to
# compute output weights through methods like scaled dot-product or additive attention.
from LLMlight import LLMlight
# Initialize with GLOBAL-REASONING context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy='global-reasoning', top_chunks=6)
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
# [LLMlight.LLM] [INFO ] Global-reasoning on 6 chunks of text.
# Processing chunk: 100%|██████████| 6/6 [03:14<00:00, 32.48s/chunk]
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
print(response)
# Based on the provided text, attention networks are computational mechanisms that use queries, keys,
# and values to determine weights via a scaled dot-product and a softmax function.
# These networks can enhance model interpretability and, when combined with feed-forward layers, achieve a computational
# complexity similar to separable convolutions.
练习4：围绕某个主题创建两个智能体之间的讨论。
在开始练习4之前，需先创建一个舞台，明确输入内容、该步骤的负责人以及结束标准，然后再修改代码。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 建议使用小型、可测试的单元而非庞大的脚本。当某个步骤失败时，故障应指向单一的责任主体，而非复杂的流程链。 对于涉及资金支出或修改生产数据的操作，必须经过人工审批。编译时的连接方式并不等同于业务功能的完整性。
# Initialize
from LLMlight import LLMlight
# temperature=0.1 Lower means a More factual debate
# temperature=1.0 Higher means more creative discussion
# top_chunks=10 Use more retrieved context
# embedding='bert' Strong semantic retrieval
# retrieval_method='naive_rag' Standard RAG retrieval
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
embedding="bert",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
# Set the database for Agent 1
agent_a.memory_init(store_path="agent_a.db")
# Add some background information database for agent 1
agent_a.memory_add("""
Large Language Models are one of the most important step we did in the field of AI
It helps the workload and the work easier and faster.
""")
agent_a.memory_add("""
Large Language Models use transformer architectures and are trained on
massive text corpora using self-supervised learning.
""")
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
embedding="bert",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
# Set the database for Agent 2
agent_b.memory_init(store_path="agent_b.db")
# Add some background information database for agent 2
agent_b.memory_add("""
The use of AI and machine learning consumes to much power and there is no need for this
new technology. The human work was good enough and there is no need to change that.
""")
agent_b.memory_add("""
Recent research shows that LLMs hallucinate and do not solve real world applications.
""")
# ====================================================
# Discussion Loop
# ====================================================
topic = "Discuss the importance of the use of Large Language Models and AI."
message = topic
for turn in range(5):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=
f"""
Topic:
{message}
""",
response_format='Give your opinion in 1-2 paragraphs and ask a question to the other agent.',
)
print("\nAgent A:")
print(response_a)
response_b = agent_b.prompt(
system='You are a farmer.',
f"""
The Data Scientist said:
{response_a}
""",
response_format='Respond to the discussion in 1-2 paragraphs and ask a follow-up question.',
)
print("\nAgent B:")
print(response_b)
message = response_b
引入第三个智能体：主持人
在“引入第三个智能体”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及结束标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 将此阶段视为输入与经过验证的输出之间的契约。为相关成果命名，定义成功判定标准，并拒绝默许的半完成状态。 对于涉及资金支出或修改生产数据的操作，必须经过人工审批。编译时的连接方式并不等同于业务上的完整性。
from LLMlight import LLMlight
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_a.memory_init(store_path="agent_a.db")
agent_a.memory_add("""
Large Language Models are one of the most important step we did in the field of AI
It helps the workload and the work easier and faster.
Large Language Models use transformer architectures and are trained on
massive text corpora using self-supervised learning.
""")
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_b.memory_init(store_path="agent_b.db")
agent_b.memory_add("""
The use of AI and machine learning consumes to much power and there is no need for this
new technology. The human work was good enough and there is no need to change that.
Recent research shows that LLMs hallucinate and do not solve real world applications.
""")
# ====================================================
# Agent C: Moderator
# ====================================================
moderator = LLMlight(
model="openai/gpt-oss-20b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.3, # lower temperature for objective summaries
)
moderator.memory_init(store_path="moderator.db")
# ====================================================
# Shared discussion memory
# ====================================================
shared_memory = LLMlight(model="openai/gpt-oss-20b")
shared_memory.memory_init(store_path="discussion.db")
# ====================================================
# Discussion Loop
# ====================================================
topic = "Discuss the importance of the use of Large Language Models and AI."
message = topic
for turn in range(5):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
# --------------------------------------------
# Agent A responds
# --------------------------------------------
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=
f"""
Current discussion:
{message}
""",
instructions='Provide your opinion and ask a question to the Farmer.',
response_format='Response can be maximum 1-2 paragraphs.'
)
print("\nData Scientist:")
print(response_a)
# --------------------------------------------
# Agent B responds
# --------------------------------------------
response_b = agent_b.prompt(
system='You are a Farmer.',
query=f"""
The Data Scientist said:
{response_a}
"""
instructions='Respond and ask a follow-up question.',
response_format='Response can be maximum 1-2 paragraphs.'
)
print("\nFarmer:")
print(response_b)
# --------------------------------------------
# Moderator summarizes
# --------------------------------------------
moderator_summary = moderator.prompt(
system='You are a neutral moderator.',
query=
f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
Perform the following tasks:
1. Summarize the key arguments.
2. Identify agreements.
3. Identify disagreements.
4. Propose one question that helps both agents move toward consensus.
""",
response_format='Keep the output concise.'
)
print("\nModerator:")
print(moderator_summary)
# Store discussion history
shared_memory.memory_add(response_a)
shared_memory.memory_add(response_b)
shared_memory.memory_add(moderator_summary)
# Next round starts from moderator guidance
message = moderator_summary
# ====================================================
# Final consensus
# ====================================================
consensus = moderator.prompt(
system='You are a neutral moderator.',
query=
"""
Review the discussion and provide:
- Main conclusions
- Remaining disagreements
- Final consensus statement
""",
response_format='Keep it under 200 words.'
)
print("\nFINAL CONSENSUS")
print("=" * 80)
print(consensus)
利用评分智能体控制对话流程。
在“控制对话流程”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及退出标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 在功能结果旁记录执行时间以及令牌或查询成本。提前显示成本可避免在流程从演示环境转向共享环境时出现意外费用。 对于会消耗资金或修改生产数据的操作，必须经过人工审批。编译时的配置并不等同于业务功能的完整性。 在“控制对话流程”阶段，应在修改代码之前明确输入参数、该步骤的负责人以及退出标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。 需同时记录正常流程和异常恢复流程。重试机制、人工审核环节以及死信处理都是产品功能的一部分，而非额外补充内容。
稍后再进行优化。from LLMlight import LLMlight
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_a.memory_init(store_path="agent_a.db", overwrite=True)
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_b.memory_init(store_path="agent_b.db", overwrite=True)
# ====================================================
# Moderator Agent (keeps discussion structured)
# ====================================================
moderator = LLMlight(
model="openai/gpt-oss-20b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.3,
)
moderator.memory_init(store_path="moderator.db", overwrite=True)
# ====================================================
# Scoring Agent (decides convergence / stopping)
# ====================================================
scoring_agent = LLMlight(
model="liquid/lfm2-24b-a2b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.0, # deterministic scoring
)
scoring_agent.memory_init(store_path="scoring.db", overwrite=True)
# ====================================================
# Shared memory (optional logging)
# ====================================================
shared_memory = LLMlight(model="liquid/lfm2-24b-a2b")
shared_memory.memory_init(store_path="discussion.db", overwrite=True)
# ====================================================
# Discussion Loop with early stopping
# ====================================================
topic = "Discuss the importance of attention mechanisms in modern AI."
message = topic
MAX_ROUNDS = 5
AGREEMENT_THRESHOLD = 0.85 # stop if convergence is high enough
for turn in range(MAX_ROUNDS):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
# --------------------------
# Agent A
# --------------------------
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=f"""
Topic:
{message}
""",
instructions='Ask a question.',
response_format='Respond in 1-2 paragraphs',
)
print("\nAgent A:")
print(response_a)
# --------------------------
# Agent B
# --------------------------
response_b = agent_b.prompt(
system='You are a Farmer.',
query=
f"""
Data Scientist said:
{response_a}
""",
instructions='continue the discussion with your own opinion.',
response_format='Respond in 1-2 paragraphs.',
)
print("\nAgent B:")
print(response_b)
# --------------------------
# Moderator summary
# --------------------------
moderator_summary = moderator.prompt(
system='You are a neutral moderator.',
query=f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
""",
instructions=
"""
Summarize:
- agreements
- disagreements
- next question toward consensus
"""
)
print("\nModerator:")
print(moderator_summary)
# --------------------------
# Scoring Agent (convergence check)
# --------------------------
score_output = scoring_agent.prompt(
system='You are a scoring system.',
query=f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
Moderator summary:
{moderator_summary}
""",
instructions='Evaluate agreement between the two agents.',
response_format=
"""
Return ONLY a number between 0 and 1:
- 1.0 = full agreement / consensus reached
- 0.0 = complete disagreement
""",
)
try:
score = float(score_output.strip())
except:
score = 0.0
print("\nAgreement Score:", score)
# --------------------------
# Store memory
# --------------------------
shared_memory.memory_add(response_a)
shared_memory.memory_add(response_b)
shared_memory.memory_add(moderator_summary)
# --------------------------
# Early stopping condition
# --------------------------
if score >= AGREEMENT_THRESHOLD:
print("\nConsensus reached early. Stopping discussion.")
break
# Next round context
message = moderator_summary
# ====================================================
# Final summary
# ====================================================
final_summary = shared_memory.prompt("""
Summarize the full discussion:
- final consensus
- key arguments
- remaining open points (if any)
""")
print("\nFINAL SUMMARY")
print("=" * 80)
print(final_summary)
# ========================
# ROUND 1
# ========================
# Agreement Score: 0.3
# ========================
# ROUND 2
# ========================
# Agreement Score: 0.7
# ========================
# ROUND 3
# ========================
# Agreement Score: 0.6
# ========================
# ROUND 4
# ========================
# Agreement Score: 0.8
# ========================
# ...
良好的指导方针至关重要。
在处理“良好的指导方针至关重要”这一阶段时，首先写下相关约定：所需的输入参数、成功标志以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改更加规范。 优先选择小型且可测试的单元，而非庞大的脚本。当某个步骤失败时，故障应指向单一的责任模块，而非复杂的流程链。 在成本较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次调用相同的大型语言模型。
response = client.prompt(
query="Explain attention mechanisms.",
instructions="""
Explain the concept for beginners.
Use exactly three paragraphs.
Include one real-world example.
""",
system="You are an experienced AI professor.",
context="some context", # This is autofilled too based on the database and RAG model.
response_format="markdown"
)
创建语言模型前的要点
在“创建语言前的要点梳理”阶段，首先需写下相关契约：所需的输入参数、成功标志以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 将此阶段视为输入与验证后输出之间的契约。为相关产物命名，明确成功判定标准，杜绝无声的半完成状态。 缓存稳定的系统指令和工具架构。重复发送相同的开头信息是导致资源浪费的常见原因。
总结：不要追求速度，要注重结构
在处理“收尾阶段”时，首先需写下功能契约：所需的输入参数、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改保持一致性。 在功能结果旁记录执行时间以及令牌或查询成本。提前明确成本信息，可避免在系统从演示环境过渡到共享环境时出现意外费用。 在耗时较高的步骤之后设置检查点。当操作员重新尝试后续节点时，恢复流程不应再次收取相同的LLM调用费用。 在处理“收尾阶段”时，首先需写下功能契约：所需的输入参数、成功标志以及部分失败时的处理方式。这份清单能确保后续的代码修改保持一致性。 需同时记录正常流程与异常恢复流程。重试机制、人工审核环节以及死信处理都是产品功能的一部分，而非后续需要补充的内容。
软件
将软件阶段视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一份完美的日志、一个故障案例以及回滚说明。 优先选择小型且可测试的单元，而非庞大的脚本。当某一步骤出错时，故障应指向单一责任点，而非复杂的流程链。 保持图结构的状态扁平且具有类型约束。嵌套的数据块会掩盖是哪个节点写了哪个字段，还会导致中断后无法继续执行。
参考资料
将参考资料阶段视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一份完美的日志、一个故障案例以及回滚说明。 将该阶段视为输入与已验证输出之间的契约。为相关成果命名，明确成功标准，拒绝默许部分完成的情况。 保持图结构的状态扁平且具有类型约束。嵌套的数据块会掩盖是哪个节点写了哪个字段，还会导致中断后无法继续执行。
操作检查清单
将操作检查清单视为可度量的基准，这样效果最佳。在扩大范围之前，先记录一份理想的运行日志、一个故障案例以及回滚说明。
将配置与应用程序代码分开。环境文件、密钥存储和功能开关应集中存放于一个位置，以便操作人员无需查看整个系统结构即可进行审计。
保持系统状态结构的扁平化与类型化。嵌套的数据结构会掩盖哪个节点修改了哪个字段的信息，还会在中断后导致恢复失败。
只要预算允许，就在持续集成过程中使用测试用例而非真实的付费 API 来执行关键路径的冒烟测试。
同时记录正常运行流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品的一部分，而非后续需要补充的内容。
保持图结构的状态简洁且类型明确。嵌套的数据块会掩盖是哪个节点修改了哪个字段，还会在中断后导致流程无法继续。
在提升栈结构之前，先冻结版本，为关键路径生成标准记录，并确认回滚步骤。共享环境需要设置速率限制、进行租户检查，同时明确密钥轮换的负责人。与其追求花哨的一次性演示，不如注重扎实的可靠性。
针对24c6cd6fa849的批注：不要将提供方密钥放入代码仓库，为每个会话设置令牌上限，并将记录存储在评估用文件旁边，以便后续模型更换时仍能保持可比性。
在将加固步骤视为可测量的表面时，第0阶段的效果最佳。在扩大范围之前，先记录一份理想的测试用例、一个故障案例以及回滚说明。在功能结果旁同时记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。
加固细节0/872：为该步骤测量实际执行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。
对于加固步骤的第1阶段，在修改代码之前需明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测系统的隐藏状态。需同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品的一部分，而非后续需要补充的内容。
强化细节1/872：记录该代码段的运行时间、错误类型以及代币消耗情况，然后依据固定的问题清单而非个人经验来判断是否保留该修改。
在处理强化笔记的第二阶段时，首先写下合约的详细内容：所需的输入参数、成功标志，以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。将这一阶段视为输入与验证后输出之间的契约，为相关组件命名，明确成功判定标准，并杜绝无声的半完成状态。
强化细节2/872：记录该代码段的运行时间、错误类型以及代币消耗情况，然后依据固定的问题清单而非个人经验来判断是否保留该修改。
加固措施第3阶段在被视为可测量的表面时效果最佳。在扩大范围之前，需记录一份理想的运行日志、一个故障案例以及回滚说明。 应将配置与应用程序代码分开。环境文件、密钥存储和功能标志应集中存放于一处，以便操作人员无需查看整个系统结构即可进行审计。
加固细节3/872：针对该措施需测量耗时、错误类型以及令牌使用情况，然后依据固定的评估标准而非个人经验来判断是否保留该变更。
在强化措施的第4阶段，应在修改代码之前明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新执行该步骤，而无需猜测隐藏状态。相比冗长的脚本，更应采用小型且可测试的单元。当某一步骤失败时，故障原因应能指向具体的责任主体，而非复杂的流程问题。
强化措施细节4/872：需记录该措施的耗时、错误类型以及令牌消耗情况，然后依据固定的评估标准而非主观判断来决定是否保留该变更。
在处理强化措施的第5阶段时，首先写下相关约定：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改保持一致性。 在功能结果旁记录执行时间以及令牌或查询成本。提前了解成本情况，可避免在系统从演示环境过渡到共享环境时出现意外费用。
强化措施细节5/872：为该阶段测量实际执行时间、错误类型以及令牌消耗情况，然后依据固定的评估标准而非个人经验来决定是否保留该修改。
将强化措施的第6阶段视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一个理想运行案例、一个失败案例以及回滚说明。 同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品本身的组成部分，而非后续需要补充的内容。
强化措施细节6/872：记录该任务的执行时间、错误类型以及代币消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。
在强化措施的第7阶段，应在修改代码之前明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。应将此阶段视为输入参数与验证后输出结果之间的契约，为相关成果命名、定义成功检测标准，并拒绝默许的半完成状态。
强化措施细节7/872：记录该任务的执行时间、错误类型以及代币消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。
在处理强化措施的第8阶段时，首先写下相关约定：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改始终符合要求。 应将配置信息与应用程序代码分开。环境文件、密钥存储以及功能开关应集中存放于一个位置，这样操作人员无需查看整个系统结构即可进行审计。
强化措施细节8/872：需测量该措施的执行时间、错误类型以及令牌消耗情况，然后依据固定的评估标准而非个人经验来决定是否保留该修改。
将强化措施的第9阶段视为可度量的对象来处理效果最佳。在扩大范围之前，先记录一份理想的操作流程、一个失败案例以及回滚说明。 相比复杂的脚本，更应采用小型且可测试的单元。当某个步骤出现故障时，故障原因应能明确指向某个具体的责任模块，而非整个混乱的流程。
强化措施细节9/872：为该记录测量运行时间、错误类型以及代币消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。
在强化措施的第10阶段，应在修改代码之前明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。应在功能结果旁记录时间以及代币或查询成本。提前了解成本情况，可避免在从演示环境过渡到共享环境时出现意外费用。
强化措施细节10/872：为该记录测量运行时间、错误类型以及代币消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。
在处理强化措施笔记的第11阶段时，首先写下相关契约：所需的输入参数、成功信号以及部分失败时的处理方式。这样的检查清单能确保后续的代码修改始终符合要求。
同时记录正常流程和故障恢复流程。重试机制、人工审核环节以及错误处理方式都是产品本身的组成部分，而非后续才添加的完善措施。
强化措施细节11/872：需测量该笔记相关的处理时间、错误类型以及令牌消耗情况，然后依据固定的评估标准而非个人经验来决定是否保留该变更。
将强化措施笔记的第12阶段视为一个可量化的目标面，效果最佳。在扩大范围之前，先记录一份理想的操作日志、一个故障案例以及回滚说明。
要把这一阶段视为输入参数与验证后输出结果之间的契约。为相关文档命名，明确成功判定标准，杜绝无声的半完成状态。
强化措施细节 12/872：记录该条注解的运行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。
对于强化措施的第13阶段，在修改代码之前需明确输入参数、该步骤的负责人以及完成标准。操作人员应能够从已知的检查点重新运行该步骤，而无需猜测隐藏状态。配置信息应置于应用程序代码之外，环境文件、密钥存储以及功能标志应集中存放于一个操作人员可审计的位置，无需查看整个系统结构。
强化措施细节 13/872：记录该条注解的运行时间、错误类型以及令牌消耗情况，然后依据固定的问题集而非个人经验来判断是否保留该变更。