pycityagent 2.0.0a22__py3-none-any.whl → 2.0.0a25__py3-none-any.whl

pycityagent/memory/memory.py

@@ -1,21 +1,25 @@
 import asyncio
 import logging
+from collections import defaultdict
+from collections.abc import Callable, Sequence
 from copy import deepcopy
 from datetime import datetime
-from typing import Any, Literal, Optional,  Union
-from collections.abc import Sequence,Callable
+from typing import Any, Literal, Optional, Union
 
 import numpy as np
+from langchain_core.embeddings import Embeddings
 from pyparsing import deque
 
 from ..utils.decorators import lock_decorator
 from .const import *
+from .faiss_query import FaissQuery
 from .profile import ProfileMemory
 from .self_define import DynamicMemory
 from .state import StateMemory
 
 logger = logging.getLogger("pycityagent")
 
+
 class Memory:
     """
     A class to manage different types of memory (state, profile, dynamic).
@@ -33,7 +37,8 @@ class Memory:
         base: Optional[dict[Any, Any]] = None,
         motion: Optional[dict[Any, Any]] = None,
         activate_timestamp: bool = False,
-        embedding_model: Any = None,
+        embedding_model: Optional[Embeddings] = None,
+        faiss_query: Optional[FaissQuery] = None,
     ) -> None:
         """
         Initializes the Memory with optional configuration.
@@ -51,20 +56,21 @@ class Memory:
             base (Optional[dict[Any, Any]], optional): base attribute dict from City Simulator.
             motion (Optional[dict[Any, Any]], optional): motion attribute dict from City Simulator.
             activate_timestamp (bool): Whether activate timestamp storage in MemoryUnit
-            embedding_model (Any): The embedding model for memory search.
+            embedding_model (Embeddings): The embedding model for memory search.
+            faiss_query (FaissQuery): The faiss_query of the agent. Defaults to None.
         """
         self.watchers: dict[str, list[Callable]] = {}
         self._lock = asyncio.Lock()
-        self.embedding_model = embedding_model
-
-        # 初始化embedding存储
-        self._embeddings = {"state": {}, "profile": {}, "dynamic": {}}
+        self._agent_id: int = -1
+        self._embedding_model = embedding_model
 
         _dynamic_config: dict[Any, Any] = {}
         _state_config: dict[Any, Any] = {}
         _profile_config: dict[Any, Any] = {}
         # 记录哪些字段需要embedding
         self._embedding_fields: dict[str, bool] = {}
+        self._embedding_field_to_doc_id: dict[Any, str] = defaultdict(str)
+        self._faiss_query = faiss_query
 
         if config is not None:
             for k, v in config.items():
@@ -135,8 +141,55 @@ class Memory:
         self._profile = ProfileMemory(
             msg=_profile_config, activate_timestamp=activate_timestamp
         )
-        self.memories = []  # 存储记忆内容
-        self.embeddings = []  # 存储记忆的向量表示
+        # self.memories = []  # 存储记忆内容
+        # self.embeddings = []  # 存储记忆的向量表示
+
+    def set_embedding_model(
+        self,
+        embedding_model: Embeddings,
+    ):
+        self._embedding_model = embedding_model
+
+    @property
+    def embedding_model(
+        self,
+    ):
+        if self._embedding_model is None:
+            raise RuntimeError(
+                f"embedding_model before assignment, please `set_embedding_model` first!"
+            )
+        return self._embedding_model
+
+    def set_faiss_query(self, faiss_query: FaissQuery):
+        """
+        Set the FaissQuery of the agent.
+        """
+        self._faiss_query = faiss_query
+
+    @property
+    def agent_id(
+        self,
+    ):
+        if self._agent_id < 0:
+            raise RuntimeError(
+                f"agent_id before assignment, please `set_agent_id` first!"
+            )
+        return self._agent_id
+
+    def set_agent_id(self, agent_id: int):
+        """
+        Set the FaissQuery of the agent.
+        """
+        self._agent_id = agent_id
+
+    @property
+    def faiss_query(self) -> FaissQuery:
+        """FaissQuery"""
+        if self._faiss_query is None:
+            raise RuntimeError(
+                f"FaissQuery access before assignment, please `set_faiss_query` first!"
+            )
+        return self._faiss_query
 
     @lock_decorator
     async def get(
@@ -192,11 +245,23 @@ class Memory:
                 if mode == "replace":
                     await _mem.update(key, value, store_snapshot)
                     # 如果字段需要embedding，则更新embedding
-                    if self.embedding_model and self._embedding_fields.get(key, False):
+                    if self._embedding_fields.get(key, False) and self.embedding_model:
                         memory_type = self._get_memory_type(_mem)
-                        self._embeddings[memory_type][key] = (
-                            await self._generate_embedding(f"{key}: {str(value)}")
+                        # 覆盖更新删除原vector
+                        orig_doc_id = self._embedding_field_to_doc_id[key]
+                        if orig_doc_id:
+                            await self.faiss_query.delete_documents(
+                                to_delete_ids=[orig_doc_id],
+                            )
+                        doc_ids: list[str] = await self.faiss_query.add_documents(
+                            agent_id=self.agent_id,
+                            documents=f"{key}: {str(value)}",
+                            extra_tags={
+                                "type": memory_type,
+                                "key": key,
+                            },
                         )
+                        self._embedding_field_to_doc_id[key] = doc_ids[0]
                     if key in self.watchers:
                         for callback in self.watchers[key]:
                             asyncio.create_task(callback())
@@ -214,13 +279,17 @@ class Memory:
                             f"Type of {type(original_value)} does not support mode `merge`, using `replace` instead!"
                         )
                         await _mem.update(key, value, store_snapshot)
-                    if self.embedding_model and self._embedding_fields.get(key, False):
+                    if self._embedding_fields.get(key, False) and self.embedding_model:
                         memory_type = self._get_memory_type(_mem)
-                        self._embeddings[memory_type][key] = (
-                            await self._generate_embedding(
-                                f"{key}: {str(original_value)}"
-                            )
+                        doc_ids = await self.faiss_query.add_documents(
+                            agent_id=self.agent_id,
+                            documents=f"{key}: {str(original_value)}",
+                            extra_tags={
+                                "type": memory_type,
+                                "key": key,
+                            },
                         )
+                        self._embedding_field_to_doc_id[key] = doc_ids[0]
                     if key in self.watchers:
                         for callback in self.watchers[key]:
                             asyncio.create_task(callback())
@@ -240,68 +309,6 @@ class Memory:
         else:
             return "dynamic"
 
-    async def _generate_embedding(self, text: str) -> np.ndarray:
-        """生成文本的向量表示
-
-        Args:
-            text: 输入文本
-
-        Returns:
-            np.ndarray: 文本的向量表示
-
-        Raises:
-            ValueError: 如果embedding_model未初始化
-        """
-        if not self.embedding_model:
-            raise RuntimeError("Embedding model not initialized")
-
-        return await self.embedding_model.embed(text)
-
-    async def search(self, query: str, top_k: int = 3) -> str:
-        """搜索相关记忆
-
-        Args:
-            query: 查询文本
-            top_k: 返回最相关的记忆数量
-
-        Returns:
-            str: 格式化的相关记忆文本
-        """
-        if not self.embedding_model:
-            return "Embedding model not initialized"
-
-        query_embedding = await self._generate_embedding(query)
-        all_results = []
-
-        # 搜索所有记忆类型中启用了embedding的字段
-        for memory_type, embeddings in self._embeddings.items():
-            for key, embedding in embeddings.items():
-                similarity = self._cosine_similarity(query_embedding, embedding)
-                value = await self.get(key)
-
-                all_results.append(
-                    {
-                        "type": memory_type,
-                        "key": key,
-                        "content": f"{key}: {str(value)}",
-                        "similarity": similarity,
-                    }
-                )
-
-        # 按相似度排序
-        all_results.sort(key=lambda x: x["similarity"], reverse=True)
-        top_results = all_results[:top_k]
-
-        # 格式化输出
-        formatted_results = []
-        for result in top_results:
-            formatted_results.append(
-                f"- [{result['type']}] {result['content']} "
-                f"(相关度: {result['similarity']:.2f})"
-            )
-
-        return "\n".join(formatted_results)
-
     async def update_batch(
         self,
         content: Union[dict, Sequence[tuple[Any, Any]]],
@@ -388,67 +395,54 @@ class Memory:
             if _snapshot:
                 await _mem.load(snapshots=_snapshot, reset_memory=reset_memory)
 
+    # async def add(self, content: str, metadata: Optional[dict] = None) -> None:
+    #     """添加新的记忆
+
+    #     Args:
+    #         content: 记忆内容
+    #         metadata: 相关元数据，如时间、地点等
+    #     """
+    #     embedding = await self.embedding_model.aembed_query(content)
+    #     self.memories.append(
+    #         {
+    #             "content": content,
+    #             "metadata": metadata or {},
+    #             "timestamp": datetime.now(),
+    #             "embedding": embedding,
+    #         }
+    #     )
+    #     self.embeddings.append(embedding)
+
     @lock_decorator
-    async def get_top_k(
-        self,
-        key: Any,
-        metric: Callable[[Any], Any],
-        top_k: Optional[int] = None,
-        mode: Union[Literal["read only"], Literal["read and write"]] = "read only",
-        preserve_order: bool = True,
-    ) -> Any:
-        """
-        Retrieves the top-k items from the memory based on the given key and metric.
+    async def search(
+        self, query: str, top_k: int = 3, filter: Optional[dict] = None
+    ) -> str:
+        """搜索相关记忆
 
         Args:
-            key (Any): The key of the item to retrieve.
-            metric (Callable[[Any], Any]): A callable function that defines the metric for ranking the items.
-            top_k (Optional[int], optional): The number of top items to retrieve. Defaults to None (all items).
-            mode (Union[Literal["read only"], Literal["read and write"]], optional): Access mode for the item. Defaults to "read only".
-            preserve_order (bool): Whether preserve original order in output values.
+            query: 查询文本
+            top_k: 返回最相关的记忆数量
+            filter (dict, optional): 记忆的筛选条件，如 {"type":"dynamic", "key":"self_define_1",}，默认为空
 
         Returns:
-            Any: The top-k items based on the specified metric.
-
-        Raises:
-            ValueError: If an invalid mode is provided.
-            KeyError: If the key is not found in any of the memory sections.
-        """
-        if mode == "read only":
-            process_func = deepcopy
-        elif mode == "read and write":
-            process_func = lambda x: x
-        else:
-            raise ValueError(f"Invalid get mode `{mode}`!")
-        for _mem in [self._state, self._profile, self._dynamic]:
-            try:
-                value = await _mem.get_top_k(key, metric, top_k, preserve_order)
-                return process_func(value)
-            except KeyError as e:
-                continue
-        raise KeyError(f"No attribute `{key}` in memories!")
-
-    async def add(self, content: str, metadata: Optional[dict] = None) -> None:
-        """添加新的记忆
-
-        Args:
-            content: 记忆内容
-            metadata: 相关元数据，如时间、地点等
+            str: 格式化的相关记忆文本
         """
-        embedding = await self.embedding_model.embed(content)
-        self.memories.append(
-            {
-                "content": content,
-                "metadata": metadata or {},
-                "timestamp": datetime.now(),
-                "embedding": embedding,
-            }
+        if not self._embedding_model:
+            return "Embedding model not initialized"
+        top_results: list[tuple[str, float, dict]] = (
+            await self.faiss_query.similarity_search(  # type:ignore
+                query=query,
+                agent_id=self.agent_id,
+                k=top_k,
+                return_score_type="similarity_score",
+                filter=filter,
+            )
         )
-        self.embeddings.append(embedding)
-
-    def _cosine_similarity(self, v1: np.ndarray, v2: np.ndarray) -> float:
-        """计算余弦相似度"""
-        dot_product = np.dot(v1, v2)
-        norm_v1 = np.linalg.norm(v1)
-        norm_v2 = np.linalg.norm(v2)
-        return dot_product / (norm_v1 * norm_v2)
+        # 格式化输出
+        formatted_results = []
+        for content, score, metadata in top_results:
+            formatted_results.append(
+                f"- [{metadata['type']}] {content} " f"(相关度: {score:.2f})"
+            )
+
+        return "\n".join(formatted_results)

pycityagent/simulation/agentgroup.py

@@ -10,12 +10,14 @@ from uuid import UUID
 
 import fastavro
 import ray
+from langchain_core.embeddings import Embeddings
 
 from ..agent import Agent, CitizenAgent, InstitutionAgent
 from ..economy.econ_client import EconomyClient
 from ..environment.simulator import Simulator
 from ..llm.llm import LLM
 from ..llm.llmconfig import LLMConfig
+from ..memory import FaissQuery
 from ..message import Messager
 from ..metrics import MlflowClient
 from ..utils import (DIALOG_SCHEMA, INSTITUTION_STATUS_SCHEMA, PROFILE_SCHEMA,
@@ -37,6 +39,7 @@ class AgentGroup:
         enable_pgsql: bool,
         pgsql_writer: ray.ObjectRef,
         mlflow_run_id: str,
+        embedding_model: Embeddings,
         logging_level: int,
     ):
         logger.setLevel(logging_level)
@@ -46,6 +49,7 @@ class AgentGroup:
         self.exp_id = exp_id
         self.enable_avro = enable_avro
         self.enable_pgsql = enable_pgsql
+        self.embedding_model = embedding_model
         if enable_avro:
             self.avro_path = avro_path / f"{self._uuid}"
             self.avro_path.mkdir(parents=True, exist_ok=True)
@@ -99,6 +103,13 @@ class AgentGroup:
         else:
             self.mlflow_client = None
 
+        # set FaissQuery
+        if self.embedding_model is not None:
+            self.faiss_query = FaissQuery(
+                embeddings=self.embedding_model,
+            )
+        else:
+            self.faiss_query = None
         for agent in self.agents:
             agent.set_exp_id(self.exp_id)  # type: ignore
             agent.set_llm_client(self.llm)
@@ -112,6 +123,12 @@ class AgentGroup:
                 agent.set_avro_file(self.avro_file)  # type: ignore
             if self.enable_pgsql:
                 agent.set_pgsql_writer(self._pgsql_writer)
+            # set memory.faiss_query
+            if self.faiss_query is not None:
+                agent.memory.set_faiss_query(self.faiss_query)
+            # set memory.embedding model
+            if self.embedding_model is not None:
+                agent.memory.set_embedding_model(self.embedding_model)
 
     async def init_agents(self):
         logger.debug(f"-----Initializing Agents in AgentGroup {self._uuid} ...")
@@ -376,32 +393,32 @@ class AgentGroup:
                             "created_at": _date_time,
                         }
                         _statuses_time_list.append((_status_dict, _date_time))
-        to_update_statues: list[tuple] = []
-        for _status_dict, _ in _statuses_time_list:
-            BASIC_KEYS = [
-                "id",
-                "day",
-                "t",
-                "lng",
-                "lat",
-                "parent_id",
-                "action",
-                "created_at",
-            ]
-            _data = [_status_dict[k] for k in BASIC_KEYS if k != "created_at"]
-            _other_dict = json.dumps(
-                {k: v for k, v in _status_dict.items() if k not in BASIC_KEYS}
-            )
-            _data.append(_other_dict)
-            _data.append(_status_dict["created_at"])
-            to_update_statues.append(tuple(_data))
-        if self._last_asyncio_pg_task is not None:
-            await self._last_asyncio_pg_task
-        self._last_asyncio_pg_task = (
-            self._pgsql_writer.async_write_status.remote(  # type:ignore
-                to_update_statues
+            to_update_statues: list[tuple] = []
+            for _status_dict, _ in _statuses_time_list:
+                BASIC_KEYS = [
+                    "id",
+                    "day",
+                    "t",
+                    "lng",
+                    "lat",
+                    "parent_id",
+                    "action",
+                    "created_at",
+                ]
+                _data = [_status_dict[k] for k in BASIC_KEYS if k != "created_at"]
+                _other_dict = json.dumps(
+                    {k: v for k, v in _status_dict.items() if k not in BASIC_KEYS}
+                )
+                _data.append(_other_dict)
+                _data.append(_status_dict["created_at"])
+                to_update_statues.append(tuple(_data))
+            if self._last_asyncio_pg_task is not None:
+                await self._last_asyncio_pg_task
+            self._last_asyncio_pg_task = (
+                self._pgsql_writer.async_write_status.remote(  # type:ignore
+                    to_update_statues
+                )
             )
-        )
 
     async def step(self):
         if not self.initialized:

pycityagent/simulation/simulation.py

@@ -14,11 +14,13 @@ from typing import Any, Optional, Union
 import pycityproto.city.economy.v2.economy_pb2 as economyv2
 import ray
 import yaml
+from langchain_core.embeddings import Embeddings
 from mosstool.map._map_util.const import AOI_START_ID
 
 from ..agent import Agent, InstitutionAgent
 from ..environment.simulator import Simulator
-from ..memory.memory import Memory
+from ..llm import SimpleEmbedding
+from ..memory import FaissQuery, Memory
 from ..message.messager import Messager
 from ..metrics import init_mlflow_connection
 from ..survey import Survey
@@ -76,6 +78,8 @@ class AgentSimulation:
 
         # storage
         _storage_config: dict[str, Any] = config.get("storage", {})
+        if _storage_config is None:
+            _storage_config = {}
         # avro
         _avro_config: dict[str, Any] = _storage_config.get("avro", {})
         self._enable_avro = _avro_config.get("enabled", False)
@@ -164,6 +168,7 @@ class AgentSimulation:
         enable_pgsql: bool,
         pgsql_writer: ray.ObjectRef,
         mlflow_run_id: str = None,  # type: ignore
+        embedding_model: Embeddings = None,  # type: ignore
         logging_level: int = logging.WARNING,
     ):
         """创建远程组"""
@@ -177,6 +182,7 @@ class AgentSimulation:
             enable_pgsql,
             pgsql_writer,
             mlflow_run_id,
+            embedding_model,
             logging_level,
         )
         return group_name, group, agents
@@ -186,6 +192,7 @@ class AgentSimulation:
         agent_count: Union[int, list[int]],
         group_size: int = 1000,
         pg_sql_writers: int = 32,
+        embedding_model: Embeddings = SimpleEmbedding(),
         memory_config_func: Optional[Union[Callable, list[Callable]]] = None,
     ) -> None:
         """初始化智能体
@@ -305,6 +312,7 @@ class AgentSimulation:
                 self.enable_pgsql,
                 _workers[i % _num_workers],  # type:ignore
                 mlflow_run_id,  # type:ignore
+                embedding_model,
                 self.logging_level,
             )
             creation_tasks.append((group_name, group, agents))

{pycityagent-2.0.0a22.dist-info → pycityagent-2.0.0a25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycityagent
-Version: 2.0.0a22
+Version: 2.0.0a25
 Summary: LLM-based城市环境agent构建库
 License: MIT
 Author: Yuwei Yan
@@ -20,10 +20,12 @@ Requires-Dist: aiohttp (==3.10.10)
 Requires-Dist: aiomqtt (>=2.3.0,<3.0.0)
 Requires-Dist: citystreetview (==1.2.4)
 Requires-Dist: dashscope (==1.14.1)
+Requires-Dist: faiss-cpu (>=1.9.0.post1,<2.0.0)
 Requires-Dist: fastavro (>=1.10.0,<2.0.0)
 Requires-Dist: geojson (==3.1.0)
 Requires-Dist: gradio (>=5.7.1,<6.0.0)
 Requires-Dist: grpcio (==1.67.1)
+Requires-Dist: langchain-community (>=0.3.13,<0.4.0)
 Requires-Dist: langchain-core (>=0.3.28,<0.4.0)
 Requires-Dist: matplotlib (==3.8.3)
 Requires-Dist: mlflow (>=2.19.0,<3.0.0)
@@ -40,6 +42,8 @@ Requires-Dist: pycityproto (>=2.1.5,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: ray (>=2.40.0,<3.0.0)
 Requires-Dist: sidecar (==0.7.0)
+Requires-Dist: torch (>=2.5.1,<3.0.0)
+Requires-Dist: transformers (>=4.47.1,<5.0.0)
 Requires-Dist: zhipuai (>=2.1.5.20230904,<3.0.0.0)
 Description-Content-Type: text/markdown
 

{pycityagent-2.0.0a22.dist-info → pycityagent-2.0.0a25.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pycityagent/__init__.py,sha256=EDxt3Su3lH1IMh9suNw7GeGL7UrXeWiZTw5KWNznDzc,637
-pycityagent/agent.py,sha256=TGW4vyaYBnNxYkr22FhGPwex3dLIeq3F-2rnELidNPA,28670
+pycityagent/__init__.py,sha256=fv0mzNGbHBF6m550yYqnuUpB8iQPWS-7EatYRK7DO4s,693
+pycityagent/agent.py,sha256=l8Oa95_K5JBWKzvZmbQe_QM_E_vaG-YstuuR55kgC6Y,29005
 pycityagent/economy/__init__.py,sha256=aonY4WHnx-6EGJ4WKrx4S-2jAkYNLtqUA04jp6q8B7w,75
 pycityagent/economy/econ_client.py,sha256=GuHK9ZBnhqW3Z7F8ViDJn_iN73yOBbbwFyJv1wLEBDk,12211
 pycityagent/environment/__init__.py,sha256=awHxlOud-btWbk0FCS4RmGJ13W84oVCkbGfcrhKqihA,240
@@ -21,7 +21,7 @@ pycityagent/environment/sim/person_service.py,sha256=5r1F2Itn7dKJ2U4hSLovrk5p4qy
 pycityagent/environment/sim/road_service.py,sha256=bKyn3_me0sGmaJVyF6eNeFbdU-9C1yWsa9L7pieDJzg,1285
 pycityagent/environment/sim/sim_env.py,sha256=HI1LcS_FotDKQ6vBnx0e49prXSABOfA20aU9KM-ZkCY,4625
 pycityagent/environment/sim/social_service.py,sha256=9EFJAwVdUuUQkNkFRn9qZRDfD1brh2fqkvasnXUEBhQ,2014
-pycityagent/environment/simulator.py,sha256=XjcxbyBIbB3Ht9z087z_oWIPAN6pP5Eq1lyf4W5atb8,12502
+pycityagent/environment/simulator.py,sha256=Vm8Rvczv20ETpAWhCYyxbnN25uoRyAv6DX7WoavjEVU,12446
 pycityagent/environment/utils/__init__.py,sha256=1m4Q1EfGvNpUsa1bgQzzCyWhfkpElnskNImjjFD3Znc,237
 pycityagent/environment/utils/base64.py,sha256=hoREzQo3FXMN79pqQLO2jgsDEvudciomyKii7MWljAM,374
 pycityagent/environment/utils/const.py,sha256=3RMNy7_bE7-23K90j9DFW_tWEzu8s7hSTgKbV-3BFl4,5327
@@ -30,14 +30,15 @@ pycityagent/environment/utils/grpc.py,sha256=6EJwKXXktIWb1NcUiJzIRmfrY0S03QAXXGc
 pycityagent/environment/utils/map_utils.py,sha256=lYOEoCFFK6-e9N5txLMMq4HUlxMqc8Uw1YrGW5oJmgg,5749
 pycityagent/environment/utils/port.py,sha256=3OM6kSUt3PxvDUOlgyiendBtETaWU8Mzk_8H0TzTmYg,295
 pycityagent/environment/utils/protobuf.py,sha256=0BsM_G7x2B_6DMIBHe9bjVuQDOXUytNRQ03g9e05F3c,1170
-pycityagent/llm/__init__.py,sha256=7klKEmCcDWJIu-F4DoAukSuKfDbLhdczrSIhpwow-sY,145
-pycityagent/llm/embedding.py,sha256=2psX_EK67oPlYe77g43EYUYams4M9AiJqxpHTFHG0n8,4253
+pycityagent/llm/__init__.py,sha256=iWs6FLgrbRVIiqOf4ILS89gkVCTvS7HFC3vG-MWuyko,205
+pycityagent/llm/embeddings.py,sha256=Nhf_tUIlaYJAZ93wW2QTCtS1wq7e8fUgdn2JketEAuQ,7600
 pycityagent/llm/llm.py,sha256=vJaaGqVuyV-GlBxrnvGKZnMDlxeTT_sGUTdxz5tYwEE,15141
 pycityagent/llm/llmconfig.py,sha256=4Ylf4OFSBEFy8jrOneeX0HvPhWEaF5jGvy1HkXK08Ro,436
 pycityagent/llm/utils.py,sha256=hoNPhvomb1u6lhFX0GctFipw74hVKb7bvUBDqwBzBYw,160
-pycityagent/memory/__init__.py,sha256=Hs2NhYpIG-lvpwPWwj4DydB1sxtjz7cuA4iDAzCXnjI,243
+pycityagent/memory/__init__.py,sha256=_Vfdo1HcLWsuuz34_i8e91nnLVYADpMlHHSVaB3xgIk,297
 pycityagent/memory/const.py,sha256=6zpJPJXWoH9-yf4RARYYff586agCoud9BRn7sPERB1g,932
-pycityagent/memory/memory.py,sha256=vJxHOI74aJDGZPFu2LbBr02ASfOYpig66fto6Gjr-6Q,18191
+pycityagent/memory/faiss_query.py,sha256=Z0JS4udyPYCIzHMq464QtHscnswu35gh9fQptikAwkQ,12976
+pycityagent/memory/memory.py,sha256=UBh4yANNHDzYZwrsvyX4ZMSHXINbu1U6g0HLNCOOCk8,17883
 pycityagent/memory/memory_base.py,sha256=QG_j3BxZvkadFEeE3uBR_kjl_xcXD1aHUVs8GEF3d6w,5654
 pycityagent/memory/profile.py,sha256=q8ZS9IBmHCg_X1GONUvXK85P6tCepTKQgXKuvuXYNXw,5203
 pycityagent/memory/self_define.py,sha256=vpZ6CIxR2grNXEIOScdpsSc59FBg0mOKelwQuTElbtQ,5200
@@ -49,8 +50,8 @@ pycityagent/metrics/__init__.py,sha256=X08PaBbGVAd7_PRGLREXWxaqm7nS82WBQpD1zvQzc
 pycityagent/metrics/mlflow_client.py,sha256=g_tHxWkWTDijtbGL74-HmiYzWVKb1y8-w12QrY9jL30,4449
 pycityagent/metrics/utils/const.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycityagent/simulation/__init__.py,sha256=P5czbcg2d8S0nbbnsQXFIhwzO4CennAhZM8OmKvAeYw,194
-pycityagent/simulation/agentgroup.py,sha256=5p68wNoEaog4nDym3xsCTporBWmxNiQ1crN3mbOHFsE,19788
-pycityagent/simulation/simulation.py,sha256=7Go_RkpkC_DuBWW21JPqlV2yXY754RqSkqzM0vTdteU,23008
+pycityagent/simulation/agentgroup.py,sha256=r8arCAQkKMhv3yr35XsYJL-MfG6o6rWwHItBmxfDtA4,20589
+pycityagent/simulation/simulation.py,sha256=9kkdgXSEOAN8wiewVFyORksti4IdVNU0opObV6ZYa9k,23344
 pycityagent/simulation/storage/pg.py,sha256=Ws04mUgRcbbvWi_eQm3PXYa6w7AQUbDPWhSU7HFtsD8,6026
 pycityagent/survey/__init__.py,sha256=rxwou8U9KeFSP7rMzXtmtp2fVFZxK4Trzi-psx9LPIs,153
 pycityagent/survey/manager.py,sha256=S5IkwTdelsdtZETChRcfCEczzwSrry_Fly9MY4s3rbk,1681
@@ -69,6 +70,6 @@ pycityagent/workflow/block.py,sha256=l-z9iJo9_USZQRyj4TLMfihK0-tnNDG0a6jVk9WhG0o
 pycityagent/workflow/prompt.py,sha256=6jI0Rq54JLv3-IXqZLYug62vse10wTI83xvf4ZX42nk,2929
 pycityagent/workflow/tool.py,sha256=xADxhNgVsjNiMxlhdwn3xGUstFOkLEG8P67ez8VmwSI,8555
 pycityagent/workflow/trigger.py,sha256=Df-MOBEDWBbM-v0dFLQLXteLsipymT4n8vqexmK2GiQ,5643
-pycityagent-2.0.0a22.dist-info/METADATA,sha256=s_gC55n1d1ZUyt1kRcYhl7h9Ymp8BQQKXZHrg93V8sg,7848
-pycityagent-2.0.0a22.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pycityagent-2.0.0a22.dist-info/RECORD,,
+pycityagent-2.0.0a25.dist-info/METADATA,sha256=lB0qL357khfixTBH-M-cX2-FxCGhsD3IuUyPqVY07uI,8033
+pycityagent-2.0.0a25.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pycityagent-2.0.0a25.dist-info/RECORD,,