letta-nightly 0.5.0.dev20241015014828__py3-none-any.whl → 0.5.0.dev20241016104103__py3-none-any.whl

letta/server/server.py

@@ -16,6 +16,7 @@ import letta.system as system
 from letta.agent import Agent, save_agent
 from letta.agent_store.db import attach_base
 from letta.agent_store.storage import StorageConnector, TableType
+from letta.client.utils import derive_function_name_regex
 from letta.credentials import LettaCredentials
 from letta.data_sources.connectors import DataConnector, load_data
 
@@ -72,9 +73,13 @@ 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.memory import (
+    ArchivalMemorySummary,
+    ContextWindowOverview,
+    Memory,
+    RecallMemorySummary,
+)
 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
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
@@ -411,6 +416,7 @@ class SyncServer(Server):
             raise ValueError(f"messages should be a Message or a list of Message, got {type(input_messages)}")
 
         logger.debug(f"Got input messages: {input_messages}")
+        letta_agent = None
         try:
 
             # Get the agent object (loaded in memory)
@@ -422,83 +428,14 @@ class SyncServer(Server):
             token_streaming = letta_agent.interface.streaming_mode if hasattr(letta_agent.interface, "streaming_mode") else False
 
             logger.debug(f"Starting agent step")
-            no_verify = True
-            next_input_message = input_messages
-            counter = 0
-            total_usage = UsageStatistics()
-            step_count = 0
-            while True:
-                step_response = letta_agent.step(
-                    messages=next_input_message,
-                    first_message=False,
-                    skip_verify=no_verify,
-                    return_dicts=False,
-                    stream=token_streaming,
-                    # timestamp=timestamp,
-                    ms=self.ms,
-                )
-                step_response.messages
-                heartbeat_request = step_response.heartbeat_request
-                function_failed = step_response.function_failed
-                token_warning = step_response.in_context_memory_warning
-                usage = step_response.usage
-
-                step_count += 1
-                total_usage += usage
-                counter += 1
-                letta_agent.interface.step_complete()
-
-                logger.debug("Saving agent state")
-                # save updated state
-                save_agent(letta_agent, self.ms)
-
-                # Chain stops
-                if not self.chaining:
-                    logger.debug("No chaining, stopping after one step")
-                    break
-                elif self.max_chaining_steps is not None and counter > self.max_chaining_steps:
-                    logger.debug(f"Hit max chaining steps, stopping after {counter} steps")
-                    break
-                # Chain handlers
-                elif token_warning:
-                    assert letta_agent.agent_state.user_id is not None
-                    next_input_message = Message.dict_to_message(
-                        agent_id=letta_agent.agent_state.id,
-                        user_id=letta_agent.agent_state.user_id,
-                        model=letta_agent.model,
-                        openai_message_dict={
-                            "role": "user",  # TODO: change to system?
-                            "content": system.get_token_limit_warning(),
-                        },
-                    )
-                    continue  # always chain
-                elif function_failed:
-                    assert letta_agent.agent_state.user_id is not None
-                    next_input_message = Message.dict_to_message(
-                        agent_id=letta_agent.agent_state.id,
-                        user_id=letta_agent.agent_state.user_id,
-                        model=letta_agent.model,
-                        openai_message_dict={
-                            "role": "user",  # TODO: change to system?
-                            "content": system.get_heartbeat(constants.FUNC_FAILED_HEARTBEAT_MESSAGE),
-                        },
-                    )
-                    continue  # always chain
-                elif heartbeat_request:
-                    assert letta_agent.agent_state.user_id is not None
-                    next_input_message = Message.dict_to_message(
-                        agent_id=letta_agent.agent_state.id,
-                        user_id=letta_agent.agent_state.user_id,
-                        model=letta_agent.model,
-                        openai_message_dict={
-                            "role": "user",  # TODO: change to system?
-                            "content": system.get_heartbeat(constants.REQ_HEARTBEAT_MESSAGE),
-                        },
-                    )
-                    continue  # always chain
-                # Letta no-op / yield
-                else:
-                    break
+            usage_stats = letta_agent.step(
+                messages=input_messages,
+                chaining=self.chaining,
+                max_chaining_steps=self.max_chaining_steps,
+                stream=token_streaming,
+                ms=self.ms,
+                skip_verify=True,
+            )
 
         except Exception as e:
             logger.error(f"Error in server._step: {e}")
@@ -506,9 +443,10 @@ class SyncServer(Server):
             raise
         finally:
             logger.debug("Calling step_yield()")
-            letta_agent.interface.step_yield()
+            if letta_agent:
+                letta_agent.interface.step_yield()
 
-        return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)
+        return usage_stats
 
     def _command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
         """Process a CLI command"""
@@ -794,7 +732,7 @@ class SyncServer(Server):
                 message_objects.append(message)
 
         else:
-            raise ValueError(f"All messages must be of type Message or MessageCreate, got {type(messages)}")
+            raise ValueError(f"All messages must be of type Message or MessageCreate, got {[type(message) for message in messages]}")
 
         # Run the agent state forward
         return self._step(user_id=user_id, agent_id=agent_id, input_messages=message_objects)
@@ -1028,6 +966,80 @@ class SyncServer(Server):
         # TODO: probably reload the agent somehow?
         return letta_agent.agent_state
 
+    def add_tool_to_agent(
+        self,
+        agent_id: str,
+        tool_id: str,
+        user_id: str,
+    ):
+        """Update the agents core memory block, return the new state"""
+        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) is None:
+            raise ValueError(f"Agent agent_id={agent_id} does not exist")
+
+        # Get the agent object (loaded in memory)
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+
+        # Get all the tool objects from the request
+        tool_objs = []
+        tool_obj = self.ms.get_tool(tool_id=tool_id, user_id=user_id)
+        assert tool_obj, f"Tool with id={tool_id} does not exist"
+        tool_objs.append(tool_obj)
+
+        for tool in letta_agent.tools:
+            tool_obj = self.ms.get_tool(tool_id=tool.id, user_id=user_id)
+            assert tool_obj, f"Tool with id={tool.id} does not exist"
+
+            # If it's not the already added tool
+            if tool_obj.id != tool_id:
+                tool_objs.append(tool_obj)
+
+        # replace the list of tool names ("ids") inside the agent state
+        letta_agent.agent_state.tools = [tool.name for tool in tool_objs]
+
+        # then attempt to link the tools modules
+        letta_agent.link_tools(tool_objs)
+
+        # save the agent
+        save_agent(letta_agent, self.ms)
+        return letta_agent.agent_state
+
+    def remove_tool_from_agent(
+        self,
+        agent_id: str,
+        tool_id: str,
+        user_id: str,
+    ):
+        """Update the agents core memory block, return the new state"""
+        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) is None:
+            raise ValueError(f"Agent agent_id={agent_id} does not exist")
+
+        # Get the agent object (loaded in memory)
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+
+        # Get all the tool_objs
+        tool_objs = []
+        for tool in letta_agent.tools:
+            tool_obj = self.ms.get_tool(tool_id=tool.id, user_id=user_id)
+            assert tool_obj, f"Tool with id={tool.id} does not exist"
+
+            # If it's not the tool we want to remove
+            if tool_obj.id != tool_id:
+                tool_objs.append(tool_obj)
+
+        # replace the list of tool names ("ids") inside the agent state
+        letta_agent.agent_state.tools = [tool.name for tool in tool_objs]
+
+        # then attempt to link the tools modules
+        letta_agent.link_tools(tool_objs)
+
+        # save the agent
+        save_agent(letta_agent, self.ms)
+        return letta_agent.agent_state
+
     def _agent_state_to_config(self, agent_state: AgentState) -> dict:
         """Convert AgentState to a dict for a JSON response"""
         assert agent_state is not None
@@ -1683,6 +1695,9 @@ class SyncServer(Server):
 
         return job
 
+    def delete_file_from_source(self, source_id: str, file_id: str, user_id: Optional[str]) -> Optional[FileMetadata]:
+        return self.ms.delete_file_from_source(source_id=source_id, file_id=file_id, user_id=user_id)
+
     def load_data(
         self,
         user_id: str,
@@ -1811,6 +1826,15 @@ class SyncServer(Server):
         """Get tool by ID."""
         return self.ms.get_tool(tool_id=tool_id)
 
+    def tool_with_name_and_user_id_exists(self, tool: Tool, user_id: Optional[str] = None) -> bool:
+        """Check if tool exists"""
+        tool = self.ms.get_tool_with_name_and_user_id(tool_name=tool.name, user_id=user_id)
+
+        if tool is None:
+            return False
+        else:
+            return True
+
     def get_tool_id(self, name: str, user_id: str) -> Optional[str]:
         """Get tool ID from name and user_id."""
         tool = self.ms.get_tool(tool_name=name, user_id=user_id)
@@ -1818,16 +1842,27 @@ class SyncServer(Server):
             return None
         return tool.id
 
-    def update_tool(
-        self,
-        request: ToolUpdate,
-    ) -> Tool:
+    def update_tool(self, request: ToolUpdate, user_id: Optional[str] = None) -> Tool:
         """Update an existing tool"""
-        existing_tool = self.ms.get_tool(tool_id=request.id)
-        if not existing_tool:
-            raise ValueError(f"Tool does not exist")
+        if request.name:
+            existing_tool = self.ms.get_tool_with_name_and_user_id(tool_name=request.name, user_id=user_id)
+            if existing_tool is None:
+                raise ValueError(f"Tool with name={request.name}, user_id={user_id} does not exist")
+        else:
+            existing_tool = self.ms.get_tool(tool_id=request.id)
+            if existing_tool is None:
+                raise ValueError(f"Tool with id={request.id} does not exist")
+
+        # Preserve the original tool id
+        # As we can override the tool id as well
+        # This is probably bad design if this is exposed to users...
+        original_id = existing_tool.id
 
         # override updated fields
+        if request.id:
+            existing_tool.id = request.id
+        if request.description:
+            existing_tool.description = request.description
         if request.source_code:
             existing_tool.source_code = request.source_code
         if request.source_type:
@@ -1836,10 +1871,15 @@ class SyncServer(Server):
             existing_tool.tags = request.tags
         if request.json_schema:
             existing_tool.json_schema = request.json_schema
+
+        # If name is explicitly provided here, overide the tool name
         if request.name:
             existing_tool.name = request.name
+        # Otherwise, if there's no name, and there's source code, we try to derive the name
+        elif request.source_code:
+            existing_tool.name = derive_function_name_regex(request.source_code)
 
-        self.ms.update_tool(existing_tool)
+        self.ms.update_tool(original_id, existing_tool)
         return self.ms.get_tool(tool_id=request.id)
 
     def create_tool(self, request: ToolCreate, user_id: Optional[str] = None, update: bool = True) -> Tool:  # TODO: add other fields
@@ -1866,7 +1906,7 @@ class SyncServer(Server):
 
             # TODO: not sure if this always works
             func = env[functions[-1]]
-            json_schema = generate_schema(func)
+            json_schema = generate_schema(func, terminal=request.terminal)
         else:
             # provided by client
             json_schema = request.json_schema
@@ -1877,15 +1917,23 @@ class SyncServer(Server):
             assert request.name, f"Tool name must be provided in json_schema {json_schema}. This should never happen."
 
         # check if already exists:
-        existing_tool = self.ms.get_tool(tool_name=request.name, user_id=user_id)
+        existing_tool = self.ms.get_tool(tool_id=request.id, tool_name=request.name, user_id=user_id)
         if existing_tool:
             if update:
-                updated_tool = self.update_tool(ToolUpdate(id=existing_tool.id, **vars(request)))
+                # id is an optional field, so we will fill it with the existing tool id
+                if not request.id:
+                    request.id = existing_tool.id
+                updated_tool = self.update_tool(ToolUpdate(**vars(request)), user_id)
                 assert updated_tool is not None, f"Failed to update tool {request.name}"
                 return updated_tool
             else:
                 raise ValueError(f"Tool {request.name} already exists and update=False")
 
+        # check for description
+        description = None
+        if request.description:
+            description = request.description
+
         tool = Tool(
             name=request.name,
             source_code=request.source_code,
@@ -1893,9 +1941,14 @@ class SyncServer(Server):
             tags=request.tags,
             json_schema=json_schema,
             user_id=user_id,
+            description=description,
         )
+
+        if request.id:
+            tool.id = request.id
+
         self.ms.create_tool(tool)
-        created_tool = self.ms.get_tool(tool_name=request.name, user_id=user_id)
+        created_tool = self.ms.get_tool(tool_id=tool.id, user_id=user_id)
         return created_tool
 
     def delete_tool(self, tool_id: str):
@@ -2087,3 +2140,13 @@ class SyncServer(Server):
 
     def add_embedding_model(self, request: EmbeddingConfig) -> EmbeddingConfig:
         """Add a new embedding model"""
+
+    def get_agent_context_window(
+        self,
+        user_id: str,
+        agent_id: str,
+    ) -> ContextWindowOverview:
+
+        # Get the current message
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+        return letta_agent.get_context_window()

letta_nightly-0.5.0.dev20241016104103.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.1
+Name: letta-nightly
+Version: 0.5.0.dev20241016104103
+Summary: Create LLM agents with long-term memory and custom tools
+License: Apache License
+Author: Letta Team
+Author-email: contact@letta.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: autogen
+Provides-Extra: dev
+Provides-Extra: external-tools
+Provides-Extra: milvus
+Provides-Extra: ollama
+Provides-Extra: postgres
+Provides-Extra: qdrant
+Provides-Extra: server
+Provides-Extra: tests
+Requires-Dist: alembic (>=1.13.3,<2.0.0)
+Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev"
+Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev"
+Requires-Dist: chromadb (>=0.4.24,<0.5.0)
+Requires-Dist: composio-core (>=0.5.28,<0.6.0) ; extra == "external-tools"
+Requires-Dist: composio-langchain (>=0.5.28,<0.6.0) ; extra == "external-tools"
+Requires-Dist: crewai (>=0.41.1,<0.42.0) ; extra == "external-tools"
+Requires-Dist: crewai-tools (>=0.8.3,<0.9.0) ; extra == "external-tools"
+Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev"
+Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
+Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools"
+Requires-Dist: docstring-parser (>=0.16,<0.17)
+Requires-Dist: docx2txt (>=0.8,<0.9)
+Requires-Dist: fastapi (>=0.104.1,<0.105.0) ; extra == "server"
+Requires-Dist: html2text (>=2020.1.16,<2021.0.0)
+Requires-Dist: httpx (>=0.27.2,<0.28.0)
+Requires-Dist: httpx-sse (>=0.4.0,<0.5.0)
+Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev"
+Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: langchain (>=0.2.16,<0.3.0) ; extra == "external-tools"
+Requires-Dist: langchain-community (>=0.2.17,<0.3.0) ; extra == "external-tools"
+Requires-Dist: llama-index (>=0.11.9,<0.12.0)
+Requires-Dist: llama-index-embeddings-ollama (>=0.3.1,<0.4.0) ; extra == "ollama"
+Requires-Dist: llama-index-embeddings-openai (>=0.2.5,<0.3.0)
+Requires-Dist: locust (>=2.31.5,<3.0.0)
+Requires-Dist: nltk (>=3.8.1,<4.0.0)
+Requires-Dist: numpy (>=1.26.2,<2.0.0)
+Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev"
+Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres"
+Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres"
+Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev"
+Requires-Dist: prettytable (>=3.9.0,<4.0.0)
+Requires-Dist: pyautogen (==0.2.22) ; extra == "autogen"
+Requires-Dist: pydantic (>=2.7.4,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)
+Requires-Dist: pymilvus (>=2.4.3,<3.0.0) ; extra == "milvus"
+Requires-Dist: pyright (>=1.1.347,<2.0.0) ; extra == "dev"
+Requires-Dist: pytest-asyncio (>=0.23.2,<0.24.0) ; extra == "dev"
+Requires-Dist: pytest-order (>=1.2.0,<2.0.0) ; extra == "dev"
+Requires-Dist: python-box (>=7.1.1,<8.0.0)
+Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
+Requires-Dist: pytz (>=2023.3.post1,<2024.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: qdrant-client (>=1.9.1,<2.0.0) ; extra == "qdrant"
+Requires-Dist: questionary (>=2.0.1,<3.0.0)
+Requires-Dist: setuptools (>=68.2.2,<69.0.0)
+Requires-Dist: sqlalchemy (>=2.0.25,<3.0.0)
+Requires-Dist: sqlalchemy-json (>=0.7.0,<0.8.0)
+Requires-Dist: sqlalchemy-utils (>=0.41.2,<0.42.0)
+Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
+Requires-Dist: tiktoken (>=0.7.0,<0.8.0)
+Requires-Dist: tqdm (>=4.66.1,<5.0.0)
+Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server"
+Requires-Dist: websockets (>=12.0,<13.0) ; extra == "server"
+Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests"
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/Letta-logo-RGB_GreyonTransparent_cropped_small.png">
+    <source media="(prefers-color-scheme: light)" srcset="assets/Letta-logo-RGB_OffBlackonTransparent_cropped_small.png">
+    <img alt="Letta logo" src="assets/Letta-logo-RGB_GreyonOffBlack_cropped_small.png" width="500">
+  </picture>
+</p>
+
+<div align="center">
+<h1>Letta (previously MemGPT)</h1>
+
+<h3>
+
+[Homepage](https://letta.com) // [Documentation](https://docs.letta.com) // [Letta Cloud](https://forms.letta.com/early-access)
+
+</h3>
+
+**👾 Letta** is an open source framework for building stateful LLM applications. You can use Letta to build **stateful agents** with advanced reasoning capabilities and transparent long-term memory. The Letta framework is white box and model-agnostic.
+  
+[![Discord](https://img.shields.io/discord/1161736243340640419?label=Discord&logo=discord&logoColor=5865F2&style=flat-square&color=5865F2)](https://discord.gg/letta)
+[![Twitter Follow](https://img.shields.io/badge/Follow-%40Letta__AI-1DA1F2?style=flat-square&logo=x&logoColor=white)](https://twitter.com/Letta_AI)
+[![arxiv 2310.08560](https://img.shields.io/badge/Research-2310.08560-B31B1B?logo=arxiv&style=flat-square)](https://arxiv.org/abs/2310.08560)
+[![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-silver?style=flat-square)](LICENSE)
+[![Release](https://img.shields.io/github/v/release/cpacker/MemGPT?style=flat-square&label=Release&color=limegreen)](https://github.com/cpacker/MemGPT/releases)
+[![GitHub](https://img.shields.io/github/stars/cpacker/MemGPT?style=flat-square&logo=github&label=Stars&color=gold)](https://github.com/cpacker/MemGPT)
+
+</div>
+
+> [!NOTE]
+> **Looking for MemGPT?** You're in the right place!
+>
+> The MemGPT package and Docker image have been renamed to `letta` to clarify the distinction between MemGPT agents and the API server / runtime that runs LLM agents as *services*.
+>
+> You use the **Letta _framework_** to create **MemGPT _agents_**. Read more about the relationship between MemGPT and Letta [here](https://www.letta.com/blog/memgpt-and-letta).
+
+## ⚡ Quickstart
+
+The two main ways to install Letta are through **pypi** (`pip`) or via **Docker**:
+* **`pip`** (guide below) - the easiest way to try Letta, will default to using SQLite and ChromaDB for the database backends
+* **Docker** (guide [here](https://docs.letta.com/install#run-letta-with-docker)) - recommended for production settings, will default to using Postgres (+ pgvector) for the database backend
+
+### Step 1 - Install Letta using `pip`
+```sh
+$ pip install -U letta
+```
+
+### Step 2 - Set your environment variables for your chosen LLM / embedding providers
+```sh
+$ export OPENAI_API_KEY=sk-...
+```
+
+For Ollama (see our full [documentation](https://docs.letta.com/install) for examples of how to set up various providers):
+```sh
+$ export OLLAMA_BASE_URL=http://localhost:11434
+```
+
+### Step 3 - Run the Letta CLI
+
+You can create agents and chat with them via the Letta CLI tool (`letta run`):
+```sh
+$ letta run
+```
+```
+🧬 Creating new agent...
+? Select LLM model: letta-free [type=openai] [ip=https://inference.memgpt.ai]
+? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.memgpt.ai]
+->  🤖 Using persona profile: 'sam_pov'
+->  🧑 Using human profile: 'basic'
+->  🛠️  8 tools: send_message, pause_heartbeats, conversation_search, conversation_search_date, archival_memory_insert, archival_memory_search, core_memory_append, core_memory_replace
+
+🎉 Created new agent 'InspiringSpinach'
+
+Hit enter to begin (will request first Letta message)
+
+💭 User engaged. Recognize as Chad. Acknowledge presence and establish connection. Explore interests and engage in meaningful discourse.
+🤖 Hello, Chad. It's nice to meet you. I am keen on learning and exploring new ideas and concepts. Is there a specific topic you'd like to discuss today?
+
+> Enter your message: my name is Brad, not Chad...
+
+💭 A discrepancy in identity. Reflect this change in core memory. Apologize for the oversight, and rectify the error.
+⚡🧠 [function] updating memory with core_memory_replace
+         First name: Chad
+        → First name: Brad
+💭 Apologize for the mistake in recognizing his name, and begin the conversation anew, addressing him by the correct name this time.
+🤖 I apologize for the oversight, Brad. Let's restart. It's a pleasure to meet you, Brad. Is there a specific topic you'd like to discuss today?
+
+> Enter your message:
+```
+
+### Step 4 - Run the Letta server
+
+You can start the Letta API server with `letta server` (see the full API reference [here](https://docs.letta.com/api-reference)):
+```sh
+$ letta server
+```
+```
+Initializing database...
+Running: uvicorn server:app --host localhost --port 8283
+INFO:     Started server process [47750]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://localhost:8283 (Press CTRL+C to quit)
+```
+
+When you start the Letta API server, the ADE (Agent Development Environment) will be available on `http://localhost:8283`:
+<img alt="Screenshot of the Letta ADE (Agent Development Environment)" src="assets/letta_ade_screenshot.png" width="1600">
+
+In Letta, all agents are stored/persisted in the same database, so the agents you create in the CLI are accessible via the API and ADE, and vice versa. Check out the [quickstart guide on our docs](https://docs.letta.com/quickstart) for a tutorial where you create an agent in the Letta CLI and message the same agent via the Letta API.
+
+## 🤗 How to contribute
+
+Letta is an open source project built by over a hundred contributors. There are many ways to get involved in the Letta OSS project!
+
+* **Contribute to the project**: Interested in contributing? Start by reading our [Contribution Guidelines](https://github.com/cpacker/MemGPT/tree/main/CONTRIBUTING.md).
+* **Ask a question**: Join our community on [Discord](https://discord.gg/letta) and direct your questions to the `#support` channel.
+* **Report ssues or suggest features**: Have an issue or a feature request? Please submit them through our [GitHub Issues page](https://github.com/cpacker/MemGPT/issues).
+* **Explore the roadmap**: Curious about future developments? View and comment on our [project roadmap](https://github.com/cpacker/MemGPT/issues/1533).
+* **Join community events**: Stay updated with the [event calendar](https://lu.ma/berkeley-llm-meetup) or follow our [Twitter account](https://twitter.com/Letta_AI).
+
+---
+
+***Legal notices**: By using Letta and related Letta services (such as the Letta endpoint or hosted service), you are agreeing to our [privacy policy](https://www.letta.com/privacy-policy) and [terms of service](https://www.letta.com/terms-of-service).*
+