letta-nightly 0.4.1.dev20241014104152__py3-none-any.whl → 0.5.0.dev20241015014828__py3-none-any.whl

letta/server/server.py

@@ -47,6 +47,7 @@ from letta.providers import (
     AnthropicProvider,
     AzureProvider,
     GoogleAIProvider,
+    GroqProvider,
     LettaProvider,
     OllamaProvider,
     OpenAIProvider,
@@ -63,16 +64,16 @@ from letta.schemas.block import (
     CreatePersona,
     UpdateBlock,
 )
-from letta.schemas.document import Document
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
 from letta.schemas.enums import JobStatus
+from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
-from letta.schemas.message import Message, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.organization import Organization, OrganizationCreate
 from letta.schemas.passage import Passage
@@ -141,6 +142,11 @@ class Server(object):
         """Process a message from the system, internally calls step"""
         raise NotImplementedError
 
+    @abstractmethod
+    def send_messages(self, user_id: str, agent_id: str, messages: Union[MessageCreate, List[Message]]) -> None:
+        """Send a list of messages to the agent"""
+        raise NotImplementedError
+
     @abstractmethod
     def run_command(self, user_id: str, agent_id: str, command: str) -> Union[str, None]:
         """Run a command on the agent, e.g. /memory
@@ -292,6 +298,12 @@ class SyncServer(Server):
                     base_url=model_settings.vllm_api_base,
                 )
             )
+        if model_settings.groq_api_key:
+            self._enabled_providers.append(
+                GroqProvider(
+                    api_key=model_settings.groq_api_key,
+                )
+            )
 
     def save_agents(self):
         """Saves all the agents that are in the in-memory object store"""
@@ -725,6 +737,68 @@ class SyncServer(Server):
         # Run the agent state forward
         return self._step(user_id=user_id, agent_id=agent_id, input_messages=message)
 
+    def send_messages(
+        self,
+        user_id: str,
+        agent_id: str,
+        messages: Union[List[MessageCreate], List[Message]],
+        # whether or not to wrap user and system message as MemGPT-style stringified JSON
+        wrap_user_message: bool = True,
+        wrap_system_message: bool = True,
+    ) -> LettaUsageStatistics:
+        """Send a list of messages to the agent
+
+        If the messages are of type MessageCreate, we need to turn them into
+        Message objects first before sending them through step.
+
+        Otherwise, we can pass them in directly.
+        """
+        if self.ms.get_user(user_id=user_id) is None:
+            raise ValueError(f"User user_id={user_id} does not exist")
+        if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
+            raise ValueError(f"Agent agent_id={agent_id} does not exist")
+
+        message_objects: List[Message] = []
+
+        if all(isinstance(m, MessageCreate) for m in messages):
+            for message in messages:
+                assert isinstance(message, MessageCreate)
+
+                # If wrapping is eanbled, wrap with metadata before placing content inside the Message object
+                if message.role == MessageRole.user and wrap_user_message:
+                    message.text = system.package_user_message(user_message=message.text)
+                elif message.role == MessageRole.system and wrap_system_message:
+                    message.text = system.package_system_message(system_message=message.text)
+                else:
+                    raise ValueError(f"Invalid message role: {message.role}")
+
+                # Create the Message object
+                message_objects.append(
+                    Message(
+                        user_id=user_id,
+                        agent_id=agent_id,
+                        role=message.role,
+                        text=message.text,
+                        name=message.name,
+                        # assigned later?
+                        model=None,
+                        # irrelevant
+                        tool_calls=None,
+                        tool_call_id=None,
+                    )
+                )
+
+        elif all(isinstance(m, Message) for m in messages):
+            for message in messages:
+                assert isinstance(message, Message)
+                message_objects.append(message)
+
+        else:
+            raise ValueError(f"All messages must be of type Message or MessageCreate, got {type(messages)}")
+
+        # Run the agent state forward
+        return self._step(user_id=user_id, agent_id=agent_id, input_messages=message_objects)
+
     # @LockingServer.agent_lock_decorator
     def run_command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
         """Run a command on the agent"""
@@ -1596,7 +1670,7 @@ class SyncServer(Server):
         #    job.status = JobStatus.failed
         #    job.metadata_["error"] = error
         #    self.ms.update_job(job)
-        #    # TODO: delete any associated passages/documents?
+        #    # TODO: delete any associated passages/files?
 
         #    # return failed job
         #    return job
@@ -1625,11 +1699,10 @@ class SyncServer(Server):
 
         # get the data connectors
         passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
-        # TODO: add document store support
-        document_store = None  # StorageConnector.get_storage_connector(TableType.DOCUMENTS, self.config, user_id=user_id)
+        file_store = StorageConnector.get_storage_connector(TableType.FILES, self.config, user_id=user_id)
 
         # load data into the document store
-        passage_count, document_count = load_data(connector, source, passage_store, document_store)
+        passage_count, document_count = load_data(connector, source, passage_store, file_store)
         return passage_count, document_count
 
     def attach_source_to_agent(
@@ -1686,14 +1759,14 @@ class SyncServer(Server):
         # list all attached sources to an agent
         return self.ms.list_attached_sources(agent_id)
 
+    def list_files_from_source(self, source_id: str, limit: int = 1000, cursor: Optional[str] = None) -> List[FileMetadata]:
+        # list all attached sources to an agent
+        return self.ms.list_files_from_source(source_id=source_id, limit=limit, cursor=cursor)
+
     def list_data_source_passages(self, user_id: str, source_id: str) -> List[Passage]:
         warnings.warn("list_data_source_passages is not yet implemented, returning empty list.", category=UserWarning)
         return []
 
-    def list_data_source_documents(self, user_id: str, source_id: str) -> List[Document]:
-        warnings.warn("list_data_source_documents is not yet implemented, returning empty list.", category=UserWarning)
-        return []
-
     def list_all_sources(self, user_id: str) -> List[Source]:
         """List all sources (w/ extra metadata) belonging to a user"""
 
@@ -1707,9 +1780,9 @@ class SyncServer(Server):
             passage_conn = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
             num_passages = passage_conn.size({"source_id": source.id})
 
-            # TODO: add when documents table implemented
-            ## count number of documents
-            # document_conn = StorageConnector.get_storage_connector(TableType.DOCUMENTS, self.config, user_id=user_id)
+            # TODO: add when files table implemented
+            ## count number of files
+            # document_conn = StorageConnector.get_storage_connector(TableType.FILES, self.config, user_id=user_id)
             # num_documents = document_conn.size({"data_source": source.name})
             num_documents = 0