letta-nightly 0.1.7.dev20240924104148__py3-none-any.whl

letta/schemas/source.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+from typing import Optional
+
+from fastapi import UploadFile
+from pydantic import BaseModel, Field
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.letta_base import LettaBase
+from letta.utils import get_utc_time
+
+
+class BaseSource(LettaBase):
+    """
+    Shared attributes accourss all source schemas.
+    """
+
+    __id_prefix__ = "source"
+    description: Optional[str] = Field(None, description="The description of the source.")
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the passage.")
+    # NOTE: .metadata is a reserved attribute on SQLModel
+    metadata_: Optional[dict] = Field(None, description="Metadata associated with the source.")
+
+
+class SourceCreate(BaseSource):
+    name: str = Field(..., description="The name of the source.")
+    description: Optional[str] = Field(None, description="The description of the source.")
+
+
+class Source(BaseSource):
+    """
+    Representation of a source, which is a collection of documents and passages.
+
+    Parameters:
+        id (str): The ID of the source
+        name (str): The name of the source.
+        embedding_config (EmbeddingConfig): The embedding configuration used by the source.
+        created_at (datetime): The creation date of the source.
+        user_id (str): The ID of the user that created the source.
+        metadata_ (dict): Metadata associated with the source.
+        description (str): The description of the source.
+    """
+
+    id: str = BaseSource.generate_id_field()
+    name: str = Field(..., description="The name of the source.")
+    embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the source.")
+    created_at: datetime = Field(default_factory=get_utc_time, description="The creation date of the source.")
+    user_id: str = Field(..., description="The ID of the user that created the source.")
+
+
+class SourceUpdate(BaseSource):
+    id: str = Field(..., description="The ID of the source.")
+    name: Optional[str] = Field(None, description="The name of the source.")
+
+
+class UploadFileToSourceRequest(BaseModel):
+    file: UploadFile = Field(..., description="The file to upload.")
+
+
+class UploadFileToSourceResponse(BaseModel):
+    source: Source = Field(..., description="The source the file was uploaded to.")
+    added_passages: int = Field(..., description="The number of passages added to the source.")
+    added_documents: int = Field(..., description="The number of documents added to the source.")

letta/schemas/tool.py

@@ -0,0 +1,143 @@
+from typing import Dict, List, Optional
+
+from pydantic import Field
+
+from letta.functions.schema_generator import (
+    generate_crewai_tool_wrapper,
+    generate_langchain_tool_wrapper,
+    generate_schema_from_args_schema,
+)
+from letta.schemas.letta_base import LettaBase
+from letta.schemas.openai.chat_completions import ToolCall
+
+
+class BaseTool(LettaBase):
+    __id_prefix__ = "tool"
+
+    # optional fields
+    description: Optional[str] = Field(None, description="The description of the tool.")
+    source_type: Optional[str] = Field(None, description="The type of the source code.")
+    module: Optional[str] = Field(None, description="The module of the function.")
+
+    # optional: user_id (user-specific tools)
+    user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the function.")
+
+
+class Tool(BaseTool):
+    """
+    Representation of a tool, which is a function that can be called by the agent.
+
+    Parameters:
+        id (str): The unique identifier of the tool.
+        name (str): The name of the function.
+        tags (List[str]): Metadata tags.
+        source_code (str): The source code of the function.
+        json_schema (Dict): The JSON schema of the function.
+
+    """
+
+    id: str = BaseTool.generate_id_field()
+
+    name: str = Field(..., description="The name of the function.")
+    tags: List[str] = Field(..., description="Metadata tags.")
+
+    # code
+    source_code: str = Field(..., description="The source code of the function.")
+    json_schema: Dict = Field(default_factory=dict, description="The JSON schema of the function.")
+
+    def to_dict(self):
+        """
+        Convert tool into OpenAI representation.
+        """
+        return vars(
+            ToolCall(
+                tool_id=self.id,
+                tool_call_type="function",
+                function=self.module,
+            )
+        )
+
+    @classmethod
+    def from_langchain(cls, langchain_tool) -> "Tool":
+        """
+        Class method to create an instance of Tool from a Langchain tool (must be from langchain_community.tools).
+
+        Args:
+            langchain_tool (LangchainTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+
+        Returns:
+            Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
+        """
+        description = langchain_tool.description
+        source_type = "python"
+        tags = ["langchain"]
+        # NOTE: langchain tools may come from different packages
+        wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool.__class__.__name__)
+        json_schema = generate_schema_from_args_schema(langchain_tool.args_schema, name=wrapper_func_name, description=description)
+
+        # append heartbeat (necessary for triggering another reasoning step after this tool call)
+        json_schema["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to 'true' if you want to send a follow-up message or run a follow-up function.",
+        }
+        json_schema["parameters"]["required"].append("request_heartbeat")
+
+        return cls(
+            name=wrapper_func_name,
+            description=description,
+            source_type=source_type,
+            tags=tags,
+            source_code=wrapper_function_str,
+            json_schema=json_schema,
+        )
+
+    @classmethod
+    def from_crewai(cls, crewai_tool) -> "Tool":
+        """
+        Class method to create an instance of Tool from a crewAI BaseTool object.
+
+        Args:
+            crewai_tool (CrewAIBaseTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+
+        Returns:
+            Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
+        """
+        crewai_tool.name
+        description = crewai_tool.description
+        source_type = "python"
+        tags = ["crew-ai"]
+        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool.__class__.__name__)
+        json_schema = generate_schema_from_args_schema(crewai_tool.args_schema, name=wrapper_func_name, description=description)
+
+        # append heartbeat (necessary for triggering another reasoning step after this tool call)
+        json_schema["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to 'true' if you want to send a follow-up message or run a follow-up function.",
+        }
+        json_schema["parameters"]["required"].append("request_heartbeat")
+
+        return cls(
+            name=wrapper_func_name,
+            description=description,
+            source_type=source_type,
+            tags=tags,
+            source_code=wrapper_function_str,
+            json_schema=json_schema,
+        )
+
+
+class ToolCreate(BaseTool):
+    name: Optional[str] = Field(None, description="The name of the function (auto-generated from source_code if not provided).")
+    tags: List[str] = Field(..., description="Metadata tags.")
+    source_code: str = Field(..., description="The source code of the function.")
+    json_schema: Optional[Dict] = Field(
+        None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
+    )
+
+
+class ToolUpdate(ToolCreate):
+    id: str = Field(..., description="The unique identifier of the tool.")
+    name: Optional[str] = Field(None, description="The name of the function.")
+    tags: Optional[List[str]] = Field(None, description="Metadata tags.")
+    source_code: Optional[str] = Field(None, description="The source code of the function.")
+    json_schema: Optional[Dict] = Field(None, description="The JSON schema of the function.")

letta/schemas/usage.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+
+
+class LettaUsageStatistics(BaseModel):
+    """
+    Usage statistics for the agent interaction.
+
+    Attributes:
+        completion_tokens (int): The number of tokens generated by the agent.
+        prompt_tokens (int): The number of tokens in the prompt.
+        total_tokens (int): The total number of tokens processed by the agent.
+        step_count (int): The number of steps taken by the agent.
+    """
+
+    completion_tokens: int = Field(0, description="The number of tokens generated by the agent.")
+    prompt_tokens: int = Field(0, description="The number of tokens in the prompt.")
+    total_tokens: int = Field(0, description="The total number of tokens processed by the agent.")
+    step_count: int = Field(0, description="The number of steps taken by the agent.")

letta/schemas/user.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class UserBase(LettaBase):
+    __id_prefix__ = "user"
+
+
+class User(UserBase):
+    """
+    Representation of a user.
+
+    Parameters:
+        id (str): The unique identifier of the user.
+        name (str): The name of the user.
+        created_at (datetime): The creation date of the user.
+    """
+
+    id: str = UserBase.generate_id_field()
+    org_id: Optional[str] = Field(
+        ..., description="The organization id of the user"
+    )  # TODO: dont make optional, and pass in default org ID
+    name: str = Field(..., description="The name of the user.")
+    created_at: datetime = Field(default_factory=datetime.utcnow, description="The creation date of the user.")
+
+
+class UserCreate(UserBase):
+    name: Optional[str] = Field(None, description="The name of the user.")
+    org_id: Optional[str] = Field(None, description="The organization id of the user.")

letta/server/constants.py

@@ -0,0 +1,6 @@
+# WebSockets
+WS_DEFAULT_PORT = 8282
+WS_CLIENT_TIMEOUT = 30
+
+# REST
+REST_DEFAULT_PORT = 8283

letta/server/rest_api/admin/agents.py

@@ -0,0 +1,21 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from letta.schemas.agent import AgentState
+from letta.server.rest_api.interface import QueuingInterface
+from letta.server.server import SyncServer
+
+router = APIRouter()
+
+
+def setup_agents_admin_router(server: SyncServer, interface: QueuingInterface):
+    @router.get("/agents", tags=["agents"], response_model=List[AgentState])
+    def get_all_agents():
+        """
+        Get a list of all agents in the database
+        """
+        interface.clear()
+        return server.list_agents()
+
+    return router

letta/server/rest_api/admin/tools.py

@@ -0,0 +1,83 @@
+from typing import List, Literal, Optional
+
+from fastapi import APIRouter, Body, HTTPException
+from pydantic import BaseModel, Field
+
+from letta.schemas.tool import Tool as ToolModel  # TODO: modify
+from letta.server.rest_api.interface import QueuingInterface
+from letta.server.server import SyncServer
+
+router = APIRouter()
+
+
+class ListToolsResponse(BaseModel):
+    tools: List[ToolModel] = Field(..., description="List of tools (functions).")
+
+
+class CreateToolRequest(BaseModel):
+    json_schema: dict = Field(..., description="JSON schema of the tool.")
+    source_code: str = Field(..., description="The source code of the function.")
+    source_type: Optional[Literal["python"]] = Field(None, description="The type of the source code.")
+    tags: Optional[List[str]] = Field(None, description="Metadata tags.")
+
+
+class CreateToolResponse(BaseModel):
+    tool: ToolModel = Field(..., description="Information about the newly created tool.")
+
+
+def setup_tools_index_router(server: SyncServer, interface: QueuingInterface):
+    # get_current_user_with_server = partial(partial(get_current_user, server), password)
+
+    @router.delete("/tools/{tool_name}", tags=["tools"])
+    async def delete_tool(
+        tool_name: str,
+        # user_id: uuid.UUID = Depends(get_current_user_with_server), # TODO: add back when user-specific
+    ):
+        """
+        Delete a tool by name
+        """
+        # Clear the interface
+        interface.clear()
+        # tool = server.ms.delete_tool(user_id=user_id, tool_name=tool_name) TODO: add back when user-specific
+        server.ms.delete_tool(name=tool_name, user_id=None)
+
+    @router.get("/tools/{tool_name}", tags=["tools"], response_model=ToolModel)
+    async def get_tool(tool_name: str):
+        """
+        Get a tool by name
+        """
+        # Clear the interface
+        interface.clear()
+        # tool = server.ms.get_tool(user_id=user_id, tool_name=tool_name) TODO: add back when user-specific
+        tool = server.ms.get_tool(tool_name=tool_name, user_id=None)
+        if tool is None:
+            # return 404 error
+            raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} not found.")
+        return tool
+
+    @router.get("/tools", tags=["tools"], response_model=ListToolsResponse)
+    async def list_all_tools():
+        """
+        Get a list of all tools available to agents created by a user
+        """
+        # Clear the interface
+        interface.clear()
+        # tools = server.ms.list_tools(user_id=user_id) TODO: add back when user-specific
+        tools = server.ms.list_tools(user_id=None)
+        return ListToolsResponse(tools=tools)
+
+    @router.post("/tools", tags=["tools"], response_model=ToolModel)
+    async def create_tool(
+        request: CreateToolRequest = Body(...),
+    ):
+        """
+        Create a new tool
+        """
+        try:
+            return server.create_tool(
+                json_schema=request.json_schema, source_code=request.source_code, source_type=request.source_type, tags=request.tags
+            )
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to create tool: {e}")
+
+    return router

letta/server/rest_api/admin/users.py

@@ -0,0 +1,98 @@
+from typing import List, Optional
+
+from fastapi import APIRouter, Body, HTTPException, Query
+
+from letta.schemas.api_key import APIKey, APIKeyCreate
+from letta.schemas.user import User, UserCreate
+from letta.server.rest_api.interface import QueuingInterface
+from letta.server.server import SyncServer
+
+router = APIRouter()
+
+
+def setup_admin_router(server: SyncServer, interface: QueuingInterface):
+    @router.get("/users", tags=["admin"], response_model=List[User])
+    def get_all_users(cursor: Optional[str] = Query(None), limit: Optional[int] = Query(50)):
+        """
+        Get a list of all users in the database
+        """
+        try:
+            # TODO: make this call a server function
+            _, users = server.ms.get_all_users(cursor=cursor, limit=limit)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"{e}")
+        return users
+
+    @router.post("/users", tags=["admin"], response_model=User)
+    def create_user(request: UserCreate = Body(...)):
+        """
+        Create a new user in the database
+        """
+        try:
+            user = server.create_user(request)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"{e}")
+        return user
+
+    @router.delete("/users", tags=["admin"], response_model=User)
+    def delete_user(
+        user_id: str = Query(..., description="The user_id key to be deleted."),
+    ):
+        # TODO make a soft deletion, instead of a hard deletion
+        try:
+            user = server.ms.get_user(user_id=user_id)
+            if user is None:
+                raise HTTPException(status_code=404, detail=f"User does not exist")
+            server.ms.delete_user(user_id=user_id)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"{e}")
+        return user
+
+    @router.post("/users/keys", tags=["admin"], response_model=APIKey)
+    def create_new_api_key(request: APIKeyCreate = Body(...)):
+        """
+        Create a new API key for a user
+        """
+        try:
+            api_key = server.create_api_key(request)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"{e}")
+        return api_key
+
+    @router.get("/users/keys", tags=["admin"], response_model=List[APIKey])
+    def get_api_keys(
+        user_id: str = Query(..., description="The unique identifier of the user."),
+    ):
+        """
+        Get a list of all API keys for a user
+        """
+        try:
+            if server.ms.get_user(user_id=user_id) is None:
+                raise HTTPException(status_code=404, detail=f"User does not exist")
+            api_keys = server.ms.get_all_api_keys_for_user(user_id=user_id)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"{e}")
+        return api_keys
+
+    @router.delete("/users/keys", tags=["admin"], response_model=APIKey)
+    def delete_api_key(
+        api_key: str = Query(..., description="The API key to be deleted."),
+    ):
+        try:
+            return server.delete_api_key(api_key)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"{e}")
+
+    return router

letta/server/rest_api/app.py

@@ -0,0 +1,193 @@
+import json
+import logging
+import secrets
+from pathlib import Path
+from typing import Optional
+
+import typer
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from starlette.middleware.cors import CORSMiddleware
+
+from letta.server.constants import REST_DEFAULT_PORT
+
+# NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
+from letta.server.rest_api.auth.index import (
+    setup_auth_router,  # TODO: probably remove right?
+)
+from letta.server.rest_api.interface import StreamingServerInterface
+from letta.server.rest_api.routers.openai.assistants.assistants import (
+    router as openai_assistants_router,
+)
+from letta.server.rest_api.routers.openai.assistants.threads import (
+    router as openai_threads_router,
+)
+from letta.server.rest_api.routers.openai.chat_completions.chat_completions import (
+    router as openai_chat_completions_router,
+)
+
+# from letta.orm.utilities import get_db_session  # TODO(ethan) reenable once we merge ORM
+from letta.server.rest_api.routers.v1 import ROUTERS as v1_routes
+from letta.server.rest_api.routers.v1.organizations import (
+    router as organizations_router,
+)
+from letta.server.rest_api.routers.v1.users import (
+    router as users_router,  # TODO: decide on admin
+)
+from letta.server.rest_api.static_files import mount_static_files
+from letta.server.server import SyncServer
+from letta.settings import settings
+
+# TODO(ethan)
+# NOTE(charles): @ethan I had to add this to get the global as the bottom to work
+interface: StreamingServerInterface = StreamingServerInterface
+server = SyncServer(default_interface_factory=lambda: interface())
+
+# TODO: remove
+password = None
+## TODO(ethan): eventuall remove
+# if password := settings.server_pass:
+#    # if the pass was specified in the environment, use it
+#    print(f"Using existing admin server password from environment.")
+# else:
+#    # Autogenerate a password for this session and dump it to stdout
+#    password = secrets.token_urlsafe(16)
+#    #typer.secho(f"Generated admin server password for this session: {password}", fg=typer.colors.GREEN)
+
+
+ADMIN_PREFIX = "/v1/admin"
+API_PREFIX = "/v1"
+OPENAI_API_PREFIX = "/openai"
+
+
+def create_application() -> "FastAPI":
+    """the application start routine"""
+    # global server
+    # server = SyncServer(default_interface_factory=lambda: interface())
+
+    app = FastAPI(
+        swagger_ui_parameters={"docExpansion": "none"},
+        # openapi_tags=TAGS_METADATA,
+        title="Letta",
+        summary="Create LLM agents with long-term memory and custom tools 📚🦙",
+        version="1.0.0",  # TODO wire this up to the version in the package
+    )
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @app.middleware("http")
+    async def set_current_user_middleware(request: Request, call_next):
+        user_id = request.headers.get("user_id")
+        if user_id:
+            try:
+                server.set_current_user(user_id)
+            except ValueError as e:
+                # Return an HTTP 401 Unauthorized response
+                # raise HTTPException(status_code=401, detail=str(e))
+                return JSONResponse(status_code=401, content={"detail": str(e)})
+        else:
+            server.set_current_user(None)
+        response = await call_next(request)
+        return response
+
+    for route in v1_routes:
+        app.include_router(route, prefix=API_PREFIX)
+        # this gives undocumented routes for "latest" and bare api calls.
+        # we should always tie this to the newest version of the api.
+        # app.include_router(route, prefix="", include_in_schema=False)
+        app.include_router(route, prefix="/latest", include_in_schema=False)
+
+    # NOTE: ethan these are the extra routes
+    # TODO(ethan) remove
+
+    # admin/users
+    app.include_router(users_router, prefix=ADMIN_PREFIX)
+    app.include_router(organizations_router, prefix=ADMIN_PREFIX)
+
+    # openai
+    app.include_router(openai_assistants_router, prefix=OPENAI_API_PREFIX)
+    app.include_router(openai_threads_router, prefix=OPENAI_API_PREFIX)
+    app.include_router(openai_chat_completions_router, prefix=OPENAI_API_PREFIX)
+
+    # /api/auth endpoints
+    app.include_router(setup_auth_router(server, interface, password), prefix=API_PREFIX)
+
+    # / static files
+    mount_static_files(app)
+
+    @app.on_event("startup")
+    def on_startup():
+        # load the default tools
+        # from letta.orm.tool import Tool
+
+        # Tool.load_default_tools(get_db_session())
+
+        # Update the OpenAPI schema
+        if not app.openapi_schema:
+            app.openapi_schema = app.openapi()
+
+        openai_docs, letta_docs = [app.openapi_schema.copy() for _ in range(2)]
+
+        openai_docs["paths"] = {k: v for k, v in openai_docs["paths"].items() if k.startswith("/openai")}
+        openai_docs["info"]["title"] = "OpenAI Assistants API"
+        letta_docs["paths"] = {k: v for k, v in letta_docs["paths"].items() if not k.startswith("/openai")}
+        letta_docs["info"]["title"] = "Letta API"
+
+        # Split the API docs into Letta API, and OpenAI Assistants compatible API
+        for name, docs in [
+            (
+                "openai",
+                openai_docs,
+            ),
+            (
+                "letta",
+                letta_docs,
+            ),
+        ]:
+            if settings.cors_origins:
+                docs["servers"] = [{"url": host} for host in settings.cors_origins]
+            Path(f"openapi_{name}.json").write_text(json.dumps(docs, indent=2))
+
+    @app.on_event("shutdown")
+    def on_shutdown():
+        global server
+        server.save_agents()
+        # server = None
+
+    return app
+
+
+app = create_application()
+
+
+def start_server(
+    port: Optional[int] = None,
+    host: Optional[str] = None,
+    debug: bool = False,
+):
+    """Convenience method to start the server from within Python"""
+    if debug:
+        from letta.server.server import logger as server_logger
+
+        # Set the logging level
+        server_logger.setLevel(logging.DEBUG)
+        # Create a StreamHandler
+        stream_handler = logging.StreamHandler()
+        # Set the formatter (optional)
+        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        stream_handler.setFormatter(formatter)
+        # Add the handler to the logger
+        server_logger.addHandler(stream_handler)
+
+    print(f"Running: uvicorn server:app --host {host or 'localhost'} --port {port or REST_DEFAULT_PORT}")
+    uvicorn.run(
+        app,
+        host=host or "localhost",
+        port=port or REST_DEFAULT_PORT,
+    )