通过 Redis 编排 LLM 模型聊天
|
7
|
0
|
未分类

1430 字
|
24 分钟

本文中讨论的源代码已在此存储库中发布

在使用语言模型时，幻觉经常发生 - 当模型给出错误的结论时。这是由于数学模型的成本，这导致了本文分析的重要细微差别

尝试在 Ollama 上启动 NVidia Nemotron Mini 时仪器调用协议无效

尝试在 Ollama 上启动 NVidia Nemotron Mini 时仪器调用协议无效

撇开幻觉不谈，目前没有单一的工具标准：语言模型用于与外部集成交互的 XML 模板。在上面的照片中，模型没有对天气工具进行结构化调用，而是向用户发送了一个带有标签的难以理解的 XML``

重要须知

  1. 为了

    生成各种响应，语言模型同时使用伪随机数生成器的初始值和在生成各种响应时随机选择下一个标记的百分比。

    换句话说，模型在数学上是有动机的，会给你传递一个随机的文档 IDseed temperature

  2. 从多个字段填写表单时，您不能假设模型会自行填写
    通信中的数据
    首先，用于训练模型的开源数据集不包含填写复杂表单的示例。其次，为了不淹没上下文，您必须轮换通信。第三，如果检测到模型的幻觉，例如，对用户的响应中有 XML 代码，那么摆脱这种情况的唯一方法是清除对应关系

  3. 根据

    OpenAI 规范，通信消息必须具有等效于枚举的角色： - 来自语言模型的消息， - 对模型如何行为的指示， - 工具调用的结果， - 来自用户的消息。

    在轮换期间，删除消息会破坏代理的业务逻辑，带有工具执行结果的消息应与消息中的请求一起删除，反之亦然"assistant""system" "tool""user""system" "tool""assistant"

最小基元集

为了满足上述几点，您需要应用以下基元

  • PersistStorage

    您必须通过以下方式按项目对最合适的进行排序，并通过描述对最合适的项目进行排序similarity score vector search

  • PersistState

    填写表单的中间结果必须写入与消息历史记录不同的存储中，因为如果模型开始产生幻觉，则必须重置后者

  • PersistEmbedding

    用于计算列表项描述的向量嵌入的查询是付费的。计算 RAG 中行的相似性分数的工作原理如下：对于两个比较的行，计算一个特征矩阵（每行一次），然后余弦相似度允许您获得从 0.0 到 1.0 的匹配百分比。为了不产生相同的查询，已经计算的向量值应该记录在字典中，其中键是原始字符串的哈希值

其他基元

此外，要使聊天可行，您需要以下原语

  • PersistAlive

    复选框 语言模型的对话者是否联机。对计划系统维护至关重要

  • PersistMemory

    类比 HTTP 请求的上下文，一个任意键值字典，例如，您可以在其中放置用户的区域设置

  • PersistPolicy

    如果一个人问“谁的克里米亚”这个问题，他只需要被禁止，他不打算付钱。我知道 ChatGPT 是 OpenAI，我向他们支付代币

  • PersistSwarm

    在代理群中导航时，您需要保存跳转堆栈和当前活动的代理以重新启动系统，而不会取消同步状态navigate back

示例代码

生成的结构将如下所示

另一个 Redis 桌面管理器，同样的东西，但没有标志

另一个 Redis 桌面管理器，同样的东西，但没有标志

我正在复制一段源代码以供审查，您可以在链接中查看整个项目。有一个成熟的聊天，技术正在发挥作用

import {
  PersistAlive,
  PersistMemory,
  PersistPolicy,
  PersistState,
  PersistStorage,
  PersistSwarm,
  PersistEmbedding,
  History,
  type IHistoryInstance,
  type IModelMessage,
  type IPersistBase,
  type IPersistActiveAgentData,
  type IPersistNavigationStackData,
  type IPersistStateData,
  type IPersistStorageData,
  type IPersistMemoryData,
  type IPersistPolicyData,
  type IPersistAliveData,
  type IPersistEmbeddingData,
  setConfig,
} from "agent-swarm-kit";
import { singleshot } from "functools-kit";
import Redis from "ioredis";

setConfig({
  CC_PERSIST_EMBEDDING_CACHE: true,
});

declare function parseInt(s: unknown): number;

const EMBEDDING_REDIS_TTL = 604800; // 1 week
const HISTORY_REDIS_TTL = 86400; // 24 hours
const ALIVE_REDIS_TTL = 3600; // 1 hour

const getRedis = singleshot(
  () =>
    new Promise((res) => {
      const redis = new Redis({
        host: process.env.CC_REDIS_HOST || "127.0.0.1",
        port: parseInt(process.env.CC_REDIS_PORT) || 6379,
        password: process.env.CC_REDIS_PASSWORD || "",
      });
      redis.on("connect", () => {
        res(redis);
      });
      redis.on("error", (error) => {
        throw error;
      });
      redis.on("close", () => {
        throw new Error("redis connection closed");
      });
      return redis;
    })
);

History.useHistoryAdapter(
  class implements IHistoryInstance {
    private _redis: Redis = null as never;
    private _messages: IModelMessage[] = [];

    async *iterate(): AsyncIterableIterator {
      for await (const message of this._messages) {
        yield message;
      }
    }

    constructor(public readonly clientId: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
      const messages = await this._redis.lrange(
        `history:${this.clientId}:messages`,
        0,
        -1
      );
      this._messages = messages.map((msg) => JSON.parse(msg) as IModelMessage);
    });

    async push(value: IModelMessage): Promise {
      const key = `history:${this.clientId}:messages`;
      await this._redis.rpush(key, JSON.stringify(value));
      await this._redis.expire(key, HISTORY_REDIS_TTL);
      this._messages.push(value);
    }

    async pop(): Promise {
      const key = `history:${this.clientId}:messages`;
      await this._redis.lpop(key);
      return this._messages.pop() ?? null;
    }

    async dispose() {
      this._messages = [];
    }
  }
);

PersistSwarm.usePersistActiveAgentAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly swarmName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(clientId: string): Promise {
      const key = `swarm:${this.swarmName}:active_agent:${clientId}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistActiveAgent ${clientId} not found.`);
      }
      return JSON.parse(value) as IPersistActiveAgentData;
    }

    async hasValue(clientId: string): Promise {
      const key = `swarm:${this.swarmName}:active_agent:${clientId}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      clientId: string,
      entity: IPersistActiveAgentData
    ): Promise {
      const key = `swarm:${this.swarmName}:active_agent:${clientId}`;
      await this._redis.set(key, JSON.stringify(entity));
    }
  }
);

PersistSwarm.usePersistNavigationStackAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly swarmName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(clientId: string): Promise {
      const key = `swarm:${this.swarmName}:navigation_stack:${clientId}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistNavigationStack ${clientId} not found.`);
      }
      return JSON.parse(value) as IPersistNavigationStackData;
    }

    async hasValue(clientId: string): Promise {
      const key = `swarm:${this.swarmName}:navigation_stack:${clientId}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      clientId: string,
      entity: IPersistNavigationStackData
    ): Promise {
      const key = `swarm:${this.swarmName}:navigation_stack:${clientId}`;
      await this._redis.set(key, JSON.stringify(entity));
    }
  }
);

PersistState.usePersistStateAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly stateName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(clientId: string): Promise<IPersistStateData> {
      const key = `state:${this.stateName}:${clientId}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistState ${clientId} not found.`);
      }
      return JSON.parse(value) as IPersistStateData;
    }

    async hasValue(clientId: string): Promise {
      const key = `state:${this.stateName}:${clientId}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      clientId: string,
      entity: IPersistStateData
    ): Promise {
      const key = `state:${this.stateName}:${clientId}`;
      await this._redis.set(key, JSON.stringify(entity));
    }
  }
);

PersistStorage.usePersistStorageAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly storageName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(clientId: string): Promise {
      const key = `storage:${this.storageName}:${clientId}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistStorage ${clientId} not found.`);
      }
      return JSON.parse(value) as IPersistStorageData;
    }

    async hasValue(clientId: string): Promise {
      const key = `storage:${this.storageName}:${clientId}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      clientId: string,
      entity: IPersistStorageData
    ): Promise {
      const key = `storage:${this.storageName}:${clientId}`;
      await this._redis.set(key, JSON.stringify(entity));
    }
  }
);

PersistMemory.usePersistMemoryAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly memoryName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(clientId: string): Promise<IPersistMemoryData> {
      const key = `memory:${this.memoryName}:${clientId}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistMemory ${clientId} not found.`);
      }
      return JSON.parse(value) as IPersistMemoryData;
    }

    async hasValue(clientId: string): Promise {
      const key = `memory:${this.memoryName}:${clientId}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      clientId: string,
      entity: IPersistMemoryData
    ): Promise {
      const key = `memory:${this.memoryName}:${clientId}`;
      await this._redis.set(key, JSON.stringify(entity));
    }
  }
);

PersistPolicy.usePersistPolicyAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly swarmName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(policyName: string): Promise {
      const key = `policy:${this.swarmName}:${policyName}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistPolicy ${policyName} not found.`);
      }
      return JSON.parse(value) as IPersistPolicyData;
    }

    async hasValue(policyName: string): Promise {
      const key = `policy:${this.swarmName}:${policyName}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      policyName: string,
      entity: IPersistPolicyData
    ): Promise {
      const key = `policy:${this.swarmName}:${policyName}`;
      await this._redis.set(key, JSON.stringify(entity));
    }
  }
);

PersistAlive.usePersistAliveAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly swarmName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
      const pattern = `alive:${this.swarmName}:*`;
      const keys = await this._redis.keys(pattern);
      if (keys.length > 0) {
        await this._redis.del(...keys);
      }
    });

    async readValue(clientId: string): Promise {
      const key = `alive:${this.swarmName}:${clientId}`;
      const value = await this._redis.get(key);
      if (!value) {
        return { online: false };
      }
      return JSON.parse(value) as IPersistAliveData;
    }

    async hasValue(clientId: string): Promise {
      const key = `alive:${this.swarmName}:${clientId}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      clientId: string,
      entity: IPersistAliveData
    ): Promise {
      const key = `alive:${this.swarmName}:${clientId}`;
      if (!entity.online) {
        await this._redis.del(key);
        return;
      }
      await this._redis.set(key, JSON.stringify(entity));
      await this._redis.expire(key, ALIVE_REDIS_TTL);
    }
  }
);

PersistEmbedding.usePersistEmbeddingAdapter(
  class implements IPersistBase {
    private _redis: Redis = null as never;

    constructor(private readonly embeddingName: string) {}

    public waitForInit = singleshot(async () => {
      this._redis = await getRedis();
    });

    async readValue(stringHash: string): Promise {
      const key = `embedding:${this.embeddingName}:${stringHash}`;
      const value = await this._redis.get(key);
      if (!value) {
        throw new Error(`PersistEmbedding ${stringHash} not found.`);
      }
      const buffer = Buffer.from(value, "base64");
      const embeddings = Array.from(new Float64Array(buffer.buffer));
      return { embeddings };
    }

    async hasValue(stringHash: string): Promise {
      const key = `embedding:${this.embeddingName}:${stringHash}`;
      const exists = await this._redis.exists(key);
      return exists === 1;
    }

    async writeValue(
      stringHash: string,
      entity: IPersistEmbeddingData
    ): Promise {
      const key = `embedding:${this.embeddingName}:${stringHash}`;
      const buffer = Buffer.from(new Float64Array(entity.embeddings).buffer);
      await this._redis.set(key, buffer.toString("base64"));
      await this._redis.expire(key, EMBEDDING_REDIS_TTL);
    }
  }
);
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																				
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇