"
+ for message in messages:
+ date_str = message["date"]
+ date_formatted = datetime.fromisoformat(date_str.replace("Z", "+00:00")).strftime("%Y-%m-%d %H:%M:%S")
+
+ if "function_return" in message:
+ return_string = message["function_return"]
+ return_status = message["status"]
+ html_content += f"
🛠️ [{date_formatted}] Function Return ({return_status}):
"
+ html_content += f"
{return_string}
"
+ elif "internal_monologue" in message:
+ html_content += f"
💭 [{date_formatted}] Internal Monologue:
"
+ html_content += f"
{message['internal_monologue']}
"
+ elif "function_call" in message:
+ html_content += f"
🛠️ [[{date_formatted}] Function Call:
"
+ html_content += f"
{message['function_call']}
"
+ elif "assistant_message" in message:
+ html_content += f"
🤖 [{date_formatted}] Assistant Message:
"
+ html_content += f"
{message['assistant_message']}
"
+ html_content += "
"
+ html_content += "
![](\"./developer_portal_login.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "66e47b34-5feb-4660-85f0-14b5ee7f62b9",
+ "metadata": {},
+ "source": [
+ "## Part 2: Create an agent \n",
+ "We'll first start with creating a basic MemGPT agent. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "24745606-b0fb-4157-a5cd-82fd0c26711f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "basic_agent = client.create_agent(\n",
+ " name=\"basic_agent\", \n",
+ ")\n",
+ "print(f\"Created agent: {basic_agent.name}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcfb0d7b-b260-4bc0-8db2-c65f40e4afd5",
+ "metadata": {},
+ "source": [
+ "We can now send messages from the user to the agent by specifying the `agent_id`: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a37bc9aa-4efb-4b4d-a6ce-f02505cb3240",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from memgpt.client.utils import pprint \n",
+ "\n",
+ "response = client.user_message(agent_id=basic_agent.id, message=\"hello\") \n",
+ "pprint(response.messages)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9803140c-2b9d-426b-8812-9295806eb312",
+ "metadata": {},
+ "source": [
+ "### Chatting in the developer portal \n",
+ "You can also chat with the agent inside of the developer portal. Try clicking the chat button in the agent view. \n",
+ "\n",
+ "![](\"./dev_portal_agent_chat.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99ae20ec-e92e-4480-a652-b4aea28a6199",
+ "metadata": {},
+ "source": [
+ "### Adding Personalization\n",
+ "We can now create a more customized agent, but specifying a custom `human` and `persona` field. \n",
+ "* The *human* specifies the personalization information about the user interacting with the agent \n",
+ "* The *persona* specifies the behavior and personality of the event\n",
+ "\n",
+ "What makes MemGPT unique is that the starting *persona* and *human* can change over time as the agent gains new information, enabling it to have evolving memory. We'll see an example of this later in the tutorial."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c0876410-4d70-490d-a798-39938b5ce941",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: feel free to change the human and person to what you'd like \n",
+ "persona = \\\n",
+ "\"\"\"\n",
+ "You are a friendly and helpful agent!\n",
+ "\"\"\"\n",
+ "\n",
+ "human = \\\n",
+ "\"\"\"\n",
+ "I am an Accenture consultant with many specializations. My name is Sarah.\n",
+ "\"\"\"\n",
+ "\n",
+ "custom_agent = client.create_agent(\n",
+ " name=\"custom_agent\", \n",
+ " human=human, \n",
+ " persona=persona\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "21293857-80e4-46e4-b628-3912fad038e9",
+ "metadata": {},
+ "source": [
+ "### Viewing memory \n",
+ "You can view and edit the agent's memory inside of the developer console. There are two type of memory, *core* and *archival* memory: \n",
+ "1. Core memory stores short-term memories in the LLM's context \n",
+ "2. Archival memory stores long term memories in a vector database\n",
+ "\n",
+ "In this example, we'll look at how the agent can modify its core memory with new information. To see the agent's memory, click the \"Core Memory\" section on the developer console. \n",
+ "\n",
+ "![](\"./dev_portal_memory.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d8fa13eb-ce4b-4e4f-81b6-9d6ef6fa67c2",
+ "metadata": {},
+ "source": [
+ "### Referencing memory \n",
+ "MemGPT agents can customize their responses based on what memories they have stored. Try asking a question that related to the human and persona you provided. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fddbefe5-3b94-4a08-aa50-d80fb581c747",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "response = client.user_message(agent_id=custom_agent.id, message=\"what do I work as?\") \n",
+ "pprint(response.messages)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30497119-e208-4a4e-b482-e7cfff346263",
+ "metadata": {},
+ "source": [
+ "### Evolving memory \n",
+ "MemGPT agents have long term memory, and can evolve what they store in their memory over time. In the example below, we make a correction to the previously provided information. See how the agent processes this new information. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "679fa708-20ee-4e75-9222-b476f126bc6f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "response = client.user_message(agent_id=custom_agent.id, message=\"Actually, my name is Charles\") \n",
+ "pprint(response.messages)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "686ac5a3-be63-4afd-97ae-b7d05219dd60",
+ "metadata": {},
+ "source": [
+ "Now, look back at the developer portal and at the agent's *core memory*. Do you see a change in the *human* section of the memory? "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "878d2f49-a5a6-4483-9f69-7436bcf00cfb",
+ "metadata": {},
+ "source": [
+ "## Part 3: Adding Tools \n",
+ "MemGPT agents can be connected to custom tools. Currently, tools must be created by service administrators. However, you can add additional tools provided by the service administrator to the agent you create. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "35785d36-2674-4a00-937b-4c747e0fb6bf",
+ "metadata": {},
+ "source": [
+ "### View Available Tools "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c307a6f7-276b-49f5-8d3d-48aaaea221a7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tools = client.list_tools().tools\n",
+ "for tool in tools: \n",
+ " print(f\"Tool: {tool.name} - {tool.json_schema['description']}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "318d19dc-b9dd-448c-ab5c-9c9311d21fad",
+ "metadata": {},
+ "source": [
+ "### Create a tool using agent in the developer portal \n",
+ "Create an agent in the developer portal and toggle additional tools you want the agent to use. We recommend modifying the *persona* to notify the agent that it should be using the tools for certain tasks. \n",
+ "\n",
+ "\n",
+ "![](\"./dev_portal_tools.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aecdaa70-861a-43d5-b006-fecd90a8ed19",
+ "metadata": {},
+ "source": [
+ "## Part 4: Cleanup (optional) \n",
+ "You can cleanup the agents you creating the following command to delete your agents: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1320d9c9-170b-48a8-b5e8-70737b1a8aac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for agent in client.list_agents().agents: \n",
+ " client.delete_agent(agent[\"id\"])\n",
+ " print(f\"Deleted agent {agent['name']} with ID {agent['id']}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "510675a8-22bc-4f9f-9c79-91e2ffa9caf9",
+ "metadata": {},
+ "source": [
+ "## 🎉 Congrats, you're done with day 1 of MemGPT! \n",
+ "For day 2, we'll go over how to connect *data sources* to MemGPT to run RAG agents. "
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "memgpt",
+ "language": "python",
+ "name": "memgpt"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.2"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/memgpt/__init__.py b/memgpt/__init__.py
index 73ffdfc859..6246330ee3 100644
--- a/memgpt/__init__.py
+++ b/memgpt/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.3.15"
+__version__ = "0.3.17"
from memgpt.client.admin import Admin
from memgpt.client.client import create_client
diff --git a/memgpt/agent.py b/memgpt/agent.py
index ee51989727..9e72b568c2 100644
--- a/memgpt/agent.py
+++ b/memgpt/agent.py
@@ -87,9 +87,14 @@ def link_functions(function_schemas: list):
raise ValueError(f"While loading agent.state.functions encountered a bad function schema object with no name:\n{f_schema}")
linked_function = available_functions.get(f_name)
if linked_function is None:
- raise ValueError(
+ # raise ValueError(
+ # f"Function '{f_name}' was specified in agent.state.functions, but is not in function library:\n{available_functions.keys()}"
+ # )
+ print(
f"Function '{f_name}' was specified in agent.state.functions, but is not in function library:\n{available_functions.keys()}"
)
+ continue
+
# Once we find a matching function, make sure the schema is identical
if json.dumps(f_schema, ensure_ascii=JSON_ENSURE_ASCII) != json.dumps(
linked_function["json_schema"], ensure_ascii=JSON_ENSURE_ASCII
diff --git a/memgpt/agent_store/milvus.py b/memgpt/agent_store/milvus.py
new file mode 100644
index 0000000000..0449586342
--- /dev/null
+++ b/memgpt/agent_store/milvus.py
@@ -0,0 +1,198 @@
+import uuid
+from copy import deepcopy
+from typing import Dict, Iterator, List, Optional, cast
+
+from pymilvus import DataType, MilvusClient
+from pymilvus.client.constants import ConsistencyLevel
+
+from memgpt.agent_store.storage import StorageConnector, TableType
+from memgpt.config import MemGPTConfig
+from memgpt.constants import MAX_EMBEDDING_DIM
+from memgpt.data_types import Passage, Record, RecordType
+from memgpt.utils import datetime_to_timestamp, printd, timestamp_to_datetime
+
+
+class MilvusStorageConnector(StorageConnector):
+ """Storage via Milvus"""
+
+ def __init__(self, table_type: str, config: MemGPTConfig, user_id, agent_id=None):
+ super().__init__(table_type=table_type, config=config, user_id=user_id, agent_id=agent_id)
+
+ assert table_type in [TableType.ARCHIVAL_MEMORY, TableType.PASSAGES], "Milvus only supports archival memory"
+ if config.archival_storage_uri:
+ self.client = MilvusClient(uri=config.archival_storage_uri)
+ self._create_collection()
+ else:
+ raise ValueError("Please set `archival_storage_uri` in the config file when using Milvus.")
+
+ # need to be converted to strings
+ self.uuid_fields = ["id", "user_id", "agent_id", "source_id", "doc_id"]
+
+ def _create_collection(self):
+ schema = MilvusClient.create_schema(
+ auto_id=False,
+ enable_dynamic_field=True,
+ )
+ schema.add_field(field_name="id", datatype=DataType.VARCHAR, is_primary=True, max_length=65_535)
+ schema.add_field(field_name="text", datatype=DataType.VARCHAR, is_primary=False, max_length=65_535)
+ schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=MAX_EMBEDDING_DIM)
+ index_params = self.client.prepare_index_params()
+ index_params.add_index(field_name="id")
+ index_params.add_index(field_name="embedding", index_type="AUTOINDEX", metric_type="IP")
+ self.client.create_collection(
+ collection_name=self.table_name, schema=schema, index_params=index_params, consistency_level=ConsistencyLevel.Strong
+ )
+
+ def get_milvus_filter(self, filters: Optional[Dict] = {}) -> str:
+ filter_conditions = {**self.filters, **filters} if filters is not None else self.filters
+ if not filter_conditions:
+ return ""
+ conditions = []
+ for key, value in filter_conditions.items():
+ if key in self.uuid_fields or isinstance(key, str):
+ condition = f'({key} == "{value}")'
+ else:
+ condition = f"({key} == {value})"
+ conditions.append(condition)
+ filter_expr = " and ".join(conditions)
+ if len(conditions) == 1:
+ filter_expr = filter_expr[1:-1]
+ return filter_expr
+
+ def get_all_paginated(self, filters: Optional[Dict] = {}, page_size: int = 1000) -> Iterator[List[RecordType]]:
+ if not self.client.has_collection(collection_name=self.table_name):
+ yield []
+ filter_expr = self.get_milvus_filter(filters)
+ offset = 0
+ while True:
+ # Retrieve a chunk of records with the given page_size
+ query_res = self.client.query(
+ collection_name=self.table_name,
+ filter=filter_expr,
+ offset=offset,
+ limit=page_size,
+ )
+ if not query_res:
+ break
+ # Yield a list of Record objects converted from the chunk
+ yield self._list_to_records(query_res)
+
+ # Increment the offset to get the next chunk in the next iteration
+ offset += page_size
+
+ def get_all(self, filters: Optional[Dict] = {}, limit=None) -> List[RecordType]:
+ if not self.client.has_collection(collection_name=self.table_name):
+ return []
+ filter_expr = self.get_milvus_filter(filters)
+ query_res = self.client.query(
+ collection_name=self.table_name,
+ filter=filter_expr,
+ limit=limit,
+ )
+ return self._list_to_records(query_res)
+
+ def get(self, id: uuid.UUID) -> Optional[RecordType]:
+ res = self.client.get(collection_name=self.table_name, ids=str(id))
+ return self._list_to_records(res)[0] if res else None
+
+ def size(self, filters: Optional[Dict] = {}) -> int:
+ if not self.client.has_collection(collection_name=self.table_name):
+ return 0
+ filter_expr = self.get_milvus_filter(filters)
+ count_expr = "count(*)"
+ query_res = self.client.query(
+ collection_name=self.table_name,
+ filter=filter_expr,
+ output_fields=[count_expr],
+ )
+ doc_num = query_res[0][count_expr]
+ return doc_num
+
+ def insert(self, record: RecordType):
+ self.insert_many([record])
+
+ def insert_many(self, records: List[RecordType], show_progress=False):
+ if not records:
+ return
+
+ # Milvus lite currently does not support upsert, so we delete and insert instead
+ # self.client.upsert(collection_name=self.table_name, data=self._records_to_list(records))
+ ids = [str(record.id) for record in records]
+ self.client.delete(collection_name=self.table_name, ids=ids)
+ data = self._records_to_list(records)
+ self.client.insert(collection_name=self.table_name, data=data)
+
+ def query(self, query: str, query_vec: List[float], top_k: int = 10, filters: Optional[Dict] = {}) -> List[RecordType]:
+ if not self.client.has_collection(self.table_name):
+ return []
+ search_res = self.client.search(
+ collection_name=self.table_name, data=[query_vec], filter=self.get_milvus_filter(filters), limit=top_k, output_fields=["*"]
+ )[0]
+ entity_res = [res["entity"] for res in search_res]
+ return self._list_to_records(entity_res)
+
+ def delete_table(self):
+ self.client.drop_collection(collection_name=self.table_name)
+
+ def delete(self, filters: Optional[Dict] = {}):
+ if not self.client.has_collection(collection_name=self.table_name):
+ return
+ filter_expr = self.get_milvus_filter(filters)
+ self.client.delete(collection_name=self.table_name, filter=filter_expr)
+
+ def save(self):
+ # save to persistence file (nothing needs to be done)
+ printd("Saving milvus")
+
+ def _records_to_list(self, records: List[Record]) -> List[Dict]:
+ if records == []:
+ return []
+ assert all(isinstance(r, Passage) for r in records)
+ record_list = []
+ records = list(set(records))
+ for record in records:
+ record_vars = deepcopy(vars(record))
+ _id = record_vars.pop("id")
+ text = record_vars.pop("text", "")
+ embedding = record_vars.pop("embedding")
+ record_metadata = record_vars.pop("metadata_", None) or {}
+ if "created_at" in record_vars:
+ record_vars["created_at"] = datetime_to_timestamp(record_vars["created_at"])
+ record_dict = {key: value for key, value in record_vars.items() if value is not None}
+ record_dict = {
+ **record_dict,
+ **record_metadata,
+ "id": str(_id),
+ "text": text,
+ "embedding": embedding,
+ }
+ for key, value in record_dict.items():
+ if key in self.uuid_fields:
+ record_dict[key] = str(value)
+ record_list.append(record_dict)
+ return record_list
+
+ def _list_to_records(self, query_res: List[Dict]) -> List[RecordType]:
+ records = []
+ for res_dict in query_res:
+ _id = res_dict.pop("id")
+ embedding = res_dict.pop("embedding")
+ text = res_dict.pop("text")
+ metadata = deepcopy(res_dict)
+ for key, value in metadata.items():
+ if key in self.uuid_fields:
+ metadata[key] = uuid.UUID(value)
+ elif key == "created_at":
+ metadata[key] = timestamp_to_datetime(value)
+ records.append(
+ cast(
+ RecordType,
+ self.type(
+ text=text,
+ embedding=embedding,
+ id=uuid.UUID(_id),
+ **metadata,
+ ),
+ )
+ )
+ return records
diff --git a/memgpt/agent_store/qdrant.py b/memgpt/agent_store/qdrant.py
new file mode 100644
index 0000000000..640ad91ac8
--- /dev/null
+++ b/memgpt/agent_store/qdrant.py
@@ -0,0 +1,201 @@
+import os
+import uuid
+from copy import deepcopy
+from typing import Dict, Iterator, List, Optional, cast
+
+from memgpt.agent_store.storage import StorageConnector, TableType
+from memgpt.config import MemGPTConfig
+from memgpt.constants import MAX_EMBEDDING_DIM
+from memgpt.data_types import Passage, Record, RecordType
+from memgpt.utils import datetime_to_timestamp, timestamp_to_datetime
+
+TEXT_PAYLOAD_KEY = "text_content"
+METADATA_PAYLOAD_KEY = "metadata"
+
+
+class QdrantStorageConnector(StorageConnector):
+ """Storage via Qdrant"""
+
+ def __init__(self, table_type: str, config: MemGPTConfig, user_id, agent_id=None):
+ super().__init__(table_type=table_type, config=config, user_id=user_id, agent_id=agent_id)
+ try:
+ from qdrant_client import QdrantClient, models
+ except ImportError as e:
+ raise ImportError("'qdrant-client' not installed. Run `pip install qdrant-client`.") from e
+ assert table_type in [TableType.ARCHIVAL_MEMORY, TableType.PASSAGES], "Qdrant only supports archival memory"
+ if config.archival_storage_uri and len(config.archival_storage_uri.split(":")) == 2:
+ host, port = config.archival_storage_uri.split(":")
+ self.qdrant_client = QdrantClient(host=host, port=port, api_key=os.getenv("QDRANT_API_KEY"))
+ elif config.archival_storage_path:
+ self.qdrant_client = QdrantClient(path=config.archival_storage_path)
+ else:
+ raise ValueError("Qdrant storage requires either a URI or a path to the storage configured")
+ if not self.qdrant_client.collection_exists(self.table_name):
+ self.qdrant_client.create_collection(
+ collection_name=self.table_name,
+ vectors_config=models.VectorParams(
+ size=MAX_EMBEDDING_DIM,
+ distance=models.Distance.COSINE,
+ ),
+ )
+ self.uuid_fields = ["id", "user_id", "agent_id", "source_id", "doc_id"]
+
+ def get_all_paginated(self, filters: Optional[Dict] = {}, page_size: int = 10) -> Iterator[List[RecordType]]:
+ from qdrant_client import grpc
+
+ filters = self.get_qdrant_filters(filters)
+ next_offset = None
+ stop_scrolling = False
+ while not stop_scrolling:
+ results, next_offset = self.qdrant_client.scroll(
+ collection_name=self.table_name,
+ scroll_filter=filters,
+ limit=page_size,
+ offset=next_offset,
+ with_payload=True,
+ with_vectors=True,
+ )
+ stop_scrolling = next_offset is None or (
+ isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""
+ )
+ yield self.to_records(results)
+
+ def get_all(self, filters: Optional[Dict] = {}, limit=10) -> List[RecordType]:
+ if self.size(filters) == 0:
+ return []
+ filters = self.get_qdrant_filters(filters)
+ results, _ = self.qdrant_client.scroll(
+ self.table_name,
+ scroll_filter=filters,
+ limit=limit,
+ with_payload=True,
+ with_vectors=True,
+ )
+ return self.to_records(results)
+
+ def get(self, id: uuid.UUID) -> Optional[RecordType]:
+ results = self.qdrant_client.retrieve(
+ collection_name=self.table_name,
+ ids=[str(id)],
+ with_payload=True,
+ with_vectors=True,
+ )
+ if not results:
+ return None
+ return self.to_records(results)[0]
+
+ def insert(self, record: Record):
+ points = self.to_points([record])
+ self.qdrant_client.upsert(self.table_name, points=points)
+
+ def insert_many(self, records: List[RecordType], show_progress=False):
+ points = self.to_points(records)
+ self.qdrant_client.upsert(self.table_name, points=points)
+
+ def delete(self, filters: Optional[Dict] = {}):
+ filters = self.get_qdrant_filters(filters)
+ self.qdrant_client.delete(self.table_name, points_selector=filters)
+
+ def delete_table(self):
+ self.qdrant_client.delete_collection(self.table_name)
+ self.qdrant_client.close()
+
+ def size(self, filters: Optional[Dict] = {}) -> int:
+ filters = self.get_qdrant_filters(filters)
+ return self.qdrant_client.count(collection_name=self.table_name, count_filter=filters).count
+
+ def close(self):
+ self.qdrant_client.close()
+
+ def query(
+ self,
+ query: str,
+ query_vec: List[float],
+ top_k: int = 10,
+ filters: Optional[Dict] = {},
+ ) -> List[RecordType]:
+ filters = self.get_filters(filters)
+ results = self.qdrant_client.search(
+ self.table_name,
+ query_vector=query_vec,
+ query_filter=filters,
+ limit=top_k,
+ with_payload=True,
+ with_vectors=True,
+ )
+ return self.to_records(results)
+
+ def to_records(self, records: list) -> List[RecordType]:
+ parsed_records = []
+ for record in records:
+ record = deepcopy(record)
+ metadata = record.payload[METADATA_PAYLOAD_KEY]
+ text = record.payload[TEXT_PAYLOAD_KEY]
+ _id = metadata.pop("id")
+ embedding = record.vector
+ for key, value in metadata.items():
+ if key in self.uuid_fields:
+ metadata[key] = uuid.UUID(value)
+ elif key == "created_at":
+ metadata[key] = timestamp_to_datetime(value)
+ parsed_records.append(
+ cast(
+ RecordType,
+ self.type(
+ text=text,
+ embedding=embedding,
+ id=uuid.UUID(_id),
+ **metadata,
+ ),
+ )
+ )
+ return parsed_records
+
+ def to_points(self, records: List[RecordType]):
+ from qdrant_client import models
+
+ assert all(isinstance(r, Passage) for r in records)
+ points = []
+ records = list(set(records))
+ for record in records:
+ record = vars(record)
+ _id = record.pop("id")
+ text = record.pop("text", "")
+ embedding = record.pop("embedding", {})
+ record_metadata = record.pop("metadata_", None) or {}
+ if "created_at" in record:
+ record["created_at"] = datetime_to_timestamp(record["created_at"])
+ metadata = {key: value for key, value in record.items() if value is not None}
+ metadata = {
+ **metadata,
+ **record_metadata,
+ "id": str(_id),
+ }
+ for key, value in metadata.items():
+ if key in self.uuid_fields:
+ metadata[key] = str(value)
+ points.append(
+ models.PointStruct(
+ id=str(_id),
+ vector=embedding,
+ payload={
+ TEXT_PAYLOAD_KEY: text,
+ METADATA_PAYLOAD_KEY: metadata,
+ },
+ )
+ )
+ return points
+
+ def get_qdrant_filters(self, filters: Optional[Dict] = {}):
+ from qdrant_client import models
+
+ filter_conditions = {**self.filters, **filters} if filters is not None else self.filters
+ must_conditions = []
+ for key, value in filter_conditions.items():
+ match_value = str(value) if key in self.uuid_fields else value
+ field_condition = models.FieldCondition(
+ key=f"{METADATA_PAYLOAD_KEY}.{key}",
+ match=models.MatchValue(value=match_value),
+ )
+ must_conditions.append(field_condition)
+ return models.Filter(must=must_conditions)
diff --git a/memgpt/agent_store/storage.py b/memgpt/agent_store/storage.py
index a780a8efb6..215cd80e57 100644
--- a/memgpt/agent_store/storage.py
+++ b/memgpt/agent_store/storage.py
@@ -100,6 +100,10 @@ def get_storage_connector(
return ChromaStorageConnector(table_type, config, user_id, agent_id)
+ elif storage_type == "qdrant":
+ from memgpt.agent_store.qdrant import QdrantStorageConnector
+
+ return QdrantStorageConnector(table_type, config, user_id, agent_id)
# TODO: add back
# elif storage_type == "lancedb":
# from memgpt.agent_store.db import LanceDBConnector
@@ -110,7 +114,10 @@ def get_storage_connector(
from memgpt.agent_store.db import SQLLiteStorageConnector
return SQLLiteStorageConnector(table_type, config, user_id, agent_id)
+ elif storage_type == "milvus":
+ from memgpt.agent_store.milvus import MilvusStorageConnector
+ return MilvusStorageConnector(table_type, config, user_id, agent_id)
else:
raise NotImplementedError(f"Storage type {storage_type} not implemented")
diff --git a/memgpt/cli/cli.py b/memgpt/cli/cli.py
index e12f24d985..f347a8e72e 100644
--- a/memgpt/cli/cli.py
+++ b/memgpt/cli/cli.py
@@ -20,7 +20,7 @@
from memgpt.constants import CLI_WARNING_PREFIX, MEMGPT_DIR
from memgpt.credentials import MemGPTCredentials
from memgpt.data_types import EmbeddingConfig, LLMConfig, User
-from memgpt.log import logger
+from memgpt.log import get_logger
from memgpt.metadata import MetadataStore
from memgpt.migrate import migrate_all_agents, migrate_all_sources
from memgpt.server.constants import WS_DEFAULT_PORT
@@ -31,6 +31,8 @@
)
from memgpt.utils import open_folder_in_explorer, printd
+logger = get_logger(__name__)
+
def migrate(
debug: Annotated[bool, typer.Option(help="Print extra tracebacks for failed migrations")] = False,
@@ -163,7 +165,7 @@ def quickstart(
# Load the file from the relative path
script_dir = os.path.dirname(__file__) # Get the directory where the script is located
- backup_config_path = os.path.join(script_dir, "..", "..", "configs", "memgpt_hosted.json")
+ backup_config_path = os.path.join(script_dir, "..", "configs", "memgpt_hosted.json")
try:
with open(backup_config_path, "r", encoding="utf-8") as file:
backup_config = json.load(file)
@@ -176,7 +178,7 @@ def quickstart(
# Load the file from the relative path
script_dir = os.path.dirname(__file__) # Get the directory where the script is located
# print("SCRIPT", script_dir)
- backup_config_path = os.path.join(script_dir, "..", "..", "configs", "memgpt_hosted.json")
+ backup_config_path = os.path.join(script_dir, "..", "configs", "memgpt_hosted.json")
# print("FILE PATH", backup_config_path)
try:
with open(backup_config_path, "r", encoding="utf-8") as file:
@@ -215,7 +217,7 @@ def quickstart(
# Load the file from the relative path
script_dir = os.path.dirname(__file__) # Get the directory where the script is located
- backup_config_path = os.path.join(script_dir, "..", "..", "configs", "openai.json")
+ backup_config_path = os.path.join(script_dir, "..", "configs", "openai.json")
try:
with open(backup_config_path, "r", encoding="utf-8") as file:
backup_config = json.load(file)
@@ -227,7 +229,7 @@ def quickstart(
else:
# Load the file from the relative path
script_dir = os.path.dirname(__file__) # Get the directory where the script is located
- backup_config_path = os.path.join(script_dir, "..", "..", "configs", "openai.json")
+ backup_config_path = os.path.join(script_dir, "..", "configs", "openai.json")
try:
with open(backup_config_path, "r", encoding="utf-8") as file:
backup_config = json.load(file)
diff --git a/memgpt/cli/cli_config.py b/memgpt/cli/cli_config.py
index d3db4b9946..b36905f62a 100644
--- a/memgpt/cli/cli_config.py
+++ b/memgpt/cli/cli_config.py
@@ -864,6 +864,42 @@ def configure_embedding_endpoint(config: MemGPTConfig, credentials: MemGPTCreden
embedding_dim = int(embedding_dim)
except Exception:
raise ValueError(f"Failed to cast {embedding_dim} to integer.")
+ elif embedding_provider == "ollama":
+ # configure ollama embedding endpoint
+ embedding_endpoint_type = "ollama"
+ embedding_endpoint = "http://localhost:11434/api/embeddings"
+ # Source: https://github.com/ollama/ollama/blob/main/docs/api.md#generate-embeddings:~:text=http%3A//localhost%3A11434/api/embeddings
+
+ # get endpoint (is this necessary?)
+ embedding_endpoint = questionary.text("Enter Ollama API endpoint:").ask()
+ if embedding_endpoint is None:
+ raise KeyboardInterrupt
+ while not utils.is_valid_url(embedding_endpoint):
+ typer.secho(f"Endpoint must be a valid address", fg=typer.colors.YELLOW)
+ embedding_endpoint = questionary.text("Enter Ollama API endpoint:").ask()
+ if embedding_endpoint is None:
+ raise KeyboardInterrupt
+
+ # get model type
+ default_embedding_model = (
+ config.default_embedding_config.embedding_model if config.default_embedding_config else "mxbai-embed-large"
+ )
+ embedding_model = questionary.text(
+ "Enter Ollama model tag (e.g. mxbai-embed-large):",
+ default=default_embedding_model,
+ ).ask()
+ if embedding_model is None:
+ raise KeyboardInterrupt
+
+ # get model dimensions
+ default_embedding_dim = config.default_embedding_config.embedding_dim if config.default_embedding_config else "512"
+ embedding_dim = questionary.text("Enter embedding model dimensions (e.g. 512):", default=str(default_embedding_dim)).ask()
+ if embedding_dim is None:
+ raise KeyboardInterrupt
+ try:
+ embedding_dim = int(embedding_dim)
+ except Exception:
+ raise ValueError(f"Failed to cast {embedding_dim} to integer.")
else: # local models
embedding_endpoint_type = "local"
embedding_endpoint = None
@@ -875,7 +911,7 @@ def configure_embedding_endpoint(config: MemGPTConfig, credentials: MemGPTCreden
def configure_archival_storage(config: MemGPTConfig, credentials: MemGPTCredentials):
# Configure archival storage backend
- archival_storage_options = ["postgres", "chroma"]
+ archival_storage_options = ["postgres", "chroma", "milvus", "qdrant"]
archival_storage_type = questionary.select(
"Select storage backend for archival data:", archival_storage_options, default=config.archival_storage_type
).ask()
@@ -912,6 +948,26 @@ def configure_archival_storage(config: MemGPTConfig, credentials: MemGPTCredenti
if chroma_type == "persistent":
archival_storage_path = os.path.join(MEMGPT_DIR, "chroma")
+ if archival_storage_type == "qdrant":
+ qdrant_type = questionary.select("Select Qdrant backend:", ["local", "server"], default="local").ask()
+ if qdrant_type is None:
+ raise KeyboardInterrupt
+ if qdrant_type == "server":
+ archival_storage_uri = questionary.text(
+ "Enter the Qdrant instance URI (Default: localhost:6333):", default="localhost:6333"
+ ).ask()
+ if archival_storage_uri is None:
+ raise KeyboardInterrupt
+ if qdrant_type == "local":
+ archival_storage_path = os.path.join(MEMGPT_DIR, "qdrant")
+
+ if archival_storage_type == "milvus":
+ default_milvus_uri = archival_storage_path = os.path.join(MEMGPT_DIR, "milvus.db")
+ archival_storage_uri = questionary.text(
+ f"Enter the Milvus connection URI (Default: {default_milvus_uri}):", default=default_milvus_uri
+ ).ask()
+ if archival_storage_uri is None:
+ raise KeyboardInterrupt
return archival_storage_type, archival_storage_uri, archival_storage_path
# TODO: allow configuring embedding model
@@ -1043,12 +1099,12 @@ class ListChoice(str, Enum):
@app.command()
def list(arg: Annotated[ListChoice, typer.Argument]):
-
from memgpt.client.client import create_client
config = MemGPTConfig.load()
- ms = MetadataStore(config=config)
+ MetadataStore(config)
uuid.UUID(config.anon_clientid)
+ client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
table = ColorTable(theme=Themes.OCEAN)
client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
if arg == ListChoice.agents:
@@ -1145,7 +1201,7 @@ def add(
client = create_client(base_url=os.getenv("MEMGPT_BASE_URL"), token=os.getenv("MEMGPT_SERVER_PASS"))
if filename: # read from file
assert text is None, "Cannot specify both text and filename"
- with open(filename, "r") as f:
+ with open(filename, "r", encoding="utf-8") as f:
text = f.read()
if option == "persona":
persona = client.get_persona(name=name, user_id=user_id)
@@ -1159,8 +1215,8 @@ def add(
client.add_persona(name, text)
elif option == "human":
- human = client.get_human(name, user_id)
- if human is not None:
+ human = client.get_human(name=name, user_id=user_id)
+ if human:
# config if user wants to overwrite
if not questionary.confirm(f"Human {name} already exists. Overwrite?").ask():
return
diff --git a/memgpt/client/admin.py b/memgpt/client/admin.py
index 2199da8a27..a078de6d96 100644
--- a/memgpt/client/admin.py
+++ b/memgpt/client/admin.py
@@ -28,8 +28,9 @@ def __init__(self, base_url: str, token: str):
self.token = token
self.headers = {"accept": "application/json", "content-type": "application/json", "authorization": f"Bearer {token}"}
- def get_users(self):
- response = requests.get(f"{self.base_url}/admin/users", headers=self.headers)
+ def get_users(self, cursor: Optional[uuid.UUID] = None, limit: Optional[int] = 50):
+ payload = {"cursor": str(cursor) if cursor else None, "limit": limit}
+ response = requests.get(f"{self.base_url}/admin/users", headers=self.headers, json=payload)
if response.status_code != 200:
raise HTTPError(response.json())
return GetAllUsersResponse(**response.json())
@@ -63,7 +64,6 @@ def create_user(self, user_id: Optional[uuid.UUID] = None):
if response.status_code != 200:
raise HTTPError(response.json())
response_json = response.json()
- print(response_json)
return CreateUserResponse(**response_json)
def delete_user(self, user_id: uuid.UUID):
@@ -87,25 +87,25 @@ def _reset_server(self):
# tools (currently only available for admin)
def create_tool(self, name: str, file_path: str, source_type: Optional[str] = "python", tags: Optional[List[str]] = None) -> ToolModel:
"""Add a tool implemented in a file path"""
- source_code = open(file_path, "r").read()
+ source_code = open(file_path, "r", encoding="utf-8").read()
data = {"name": name, "source_code": source_code, "source_type": source_type, "tags": tags}
- response = requests.post(f"{self.base_url}/api/tools", json=data, headers=self.headers)
+ response = requests.post(f"{self.base_url}/admin/tools", json=data, headers=self.headers)
if response.status_code != 200:
raise ValueError(f"Failed to create tool: {response.text}")
return ToolModel(**response.json())
def list_tools(self) -> ListToolsResponse:
- response = requests.get(f"{self.base_url}/api/tools", headers=self.headers)
+ response = requests.get(f"{self.base_url}/admin/tools", headers=self.headers)
return ListToolsResponse(**response.json())
def delete_tool(self, name: str):
- response = requests.delete(f"{self.base_url}/api/tools/{name}", headers=self.headers)
+ response = requests.delete(f"{self.base_url}/admin/tools/{name}", headers=self.headers)
if response.status_code != 200:
raise ValueError(f"Failed to delete tool: {response.text}")
return response.json()
def get_tool(self, name: str):
- response = requests.get(f"{self.base_url}/api/tools/{name}", headers=self.headers)
+ response = requests.get(f"{self.base_url}/admin/tools/{name}", headers=self.headers)
if response.status_code == 404:
return None
elif response.status_code != 200:
diff --git a/memgpt/client/client.py b/memgpt/client/client.py
index 9802d4469e..4e4da4893c 100644
--- a/memgpt/client/client.py
+++ b/memgpt/client/client.py
@@ -639,11 +639,15 @@ def get_messages(
) -> GetAgentMessagesResponse:
params = {"before": before, "after": after, "limit": limit}
response = requests.get(f"{self.base_url}/api/agents/{agent_id}/messages-cursor", params=params, headers=self.headers)
+ if response.status_code != 200:
+ raise ValueError(f"Failed to get messages: {response.text}")
return GetAgentMessagesResponse(**response.json())
def send_message(self, agent_id: uuid.UUID, message: str, role: str, stream: Optional[bool] = False) -> UserMessageResponse:
data = {"message": message, "role": role, "stream": stream}
response = requests.post(f"{self.base_url}/api/agents/{agent_id}/messages", json=data, headers=self.headers)
+ if response.status_code != 200:
+ raise ValueError(f"Failed to send message: {response.text}")
return UserMessageResponse(**response.json())
# humans / personas
@@ -963,7 +967,7 @@ def user_message(self, agent_id: str, message: str) -> Union[List[Dict], Tuple[L
if self.auto_save:
self.save()
else:
- return self.interface.to_list()
+ return UserMessageResponse(messages=self.interface.to_list())
def run_command(self, agent_id: str, command: str) -> Union[str, None]:
self.interface.clear()
diff --git a/memgpt/client/utils.py b/memgpt/client/utils.py
new file mode 100644
index 0000000000..254a82f157
--- /dev/null
+++ b/memgpt/client/utils.py
@@ -0,0 +1,61 @@
+from datetime import datetime
+
+from IPython.display import HTML, display
+
+
+def pprint(messages):
+ """Utility function for pretty-printing the output of client.send_message in notebooks"""
+
+ css_styles = """
+
+ """
+
+ html_content = css_styles + "