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

letta/server/rest_api/routers/v1/blocks.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+
+from letta.schemas.block import Block, CreateBlock, UpdateBlock
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+if TYPE_CHECKING:
+    pass
+
+router = APIRouter(prefix="/blocks", tags=["blocks"])
+
+
+@router.get("/", response_model=List[Block], operation_id="list_memory_blocks")
+def list_blocks(
+    # query parameters
+    label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
+    templates_only: bool = Query(True, description="Whether to include only templates"),
+    name: Optional[str] = Query(None, description="Name of the block"),
+    server: SyncServer = Depends(get_letta_server),
+):
+    actor = server.get_current_user()
+
+    blocks = server.get_blocks(user_id=actor.id, label=label, template=templates_only, name=name)
+    if blocks is None:
+        return []
+    return blocks
+
+
+@router.post("/", response_model=Block, operation_id="create_memory_block")
+def create_block(
+    create_block: CreateBlock = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+):
+    actor = server.get_current_user()
+
+    create_block.user_id = actor.id
+    return server.create_block(user_id=actor.id, request=create_block)
+
+
+@router.patch("/{block_id}", response_model=Block, operation_id="update_memory_block")
+def update_block(
+    block_id: str,
+    updated_block: UpdateBlock = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+):
+    # actor = server.get_current_user()
+
+    updated_block.id = block_id
+    return server.update_block(request=updated_block)
+
+
+# TODO: delete should not return anything
+@router.delete("/{block_id}", response_model=Block, operation_id="delete_memory_block")
+def delete_block(
+    block_id: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+
+    return server.delete_block(block_id=block_id)
+
+
+@router.get("/{block_id}", response_model=Block, operation_id="get_memory_block")
+def get_block(
+    block_id: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+
+    block = server.get_block(block_id=block_id)
+    if block is None:
+        raise HTTPException(status_code=404, detail="Block not found")
+    return block

letta/server/rest_api/routers/v1/jobs.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+
+from letta.schemas.job import Job
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/jobs", tags=["jobs"])
+
+
+@router.get("/", response_model=List[Job], operation_id="list_jobs")
+def list_jobs(
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    List all jobs.
+    """
+    actor = server.get_current_user()
+
+    # TODO: add filtering by status
+    return server.list_jobs(user_id=actor.id)
+
+
+@router.get("/active", response_model=List[Job], operation_id="list_active_jobs")
+def list_active_jobs(
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    List all active jobs.
+    """
+    actor = server.get_current_user()
+
+    return server.list_active_jobs(user_id=actor.id)
+
+
+@router.get("/{job_id}", response_model=Job, operation_id="get_job")
+def get_job(
+    job_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get the status of a job.
+    """
+
+    return server.get_job(job_id=job_id)

letta/server/rest_api/routers/v1/llms.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING, List
+
+from fastapi import APIRouter, Depends
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.llm_config import LLMConfig
+from letta.server.rest_api.utils import get_letta_server
+
+if TYPE_CHECKING:
+    from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/models", tags=["models", "llms"])
+
+
+@router.get("/", response_model=List[LLMConfig], operation_id="list_models")
+def list_llm_backends(
+    server: "SyncServer" = Depends(get_letta_server),
+):
+
+    return server.list_models()
+
+
+@router.get("/embedding", response_model=List[EmbeddingConfig], operation_id="list_embedding_models")
+def list_embedding_backends(
+    server: "SyncServer" = Depends(get_letta_server),
+):
+
+    return server.list_embedding_models()

letta/server/rest_api/routers/v1/organizations.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+
+from letta.schemas.organization import Organization, OrganizationCreate
+from letta.server.rest_api.utils import get_letta_server
+
+if TYPE_CHECKING:
+    from letta.server.server import SyncServer
+
+
+router = APIRouter(prefix="/orgs", tags=["organization", "admin"])
+
+
+@router.get("/", tags=["admin"], response_model=List[Organization], operation_id="list_orgs")
+def get_all_orgs(
+    cursor: Optional[str] = Query(None),
+    limit: Optional[int] = Query(50),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get a list of all orgs in the database
+    """
+    try:
+        next_cursor, orgs = server.ms.list_organizations(cursor=cursor, limit=limit)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+    return orgs
+
+
+@router.post("/", tags=["admin"], response_model=Organization, operation_id="create_organization")
+def create_org(
+    request: OrganizationCreate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Create a new org in the database
+    """
+
+    org = server.create_organization(request)
+    return org
+
+
+@router.delete("/", tags=["admin"], response_model=Organization, operation_id="delete_organization")
+def delete_org(
+    org_id: str = Query(..., description="The org_id key to be deleted."),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    # TODO make a soft deletion, instead of a hard deletion
+    try:
+        org = server.ms.get_organization(org_id=org_id)
+        if org is None:
+            raise HTTPException(status_code=404, detail=f"Organization does not exist")
+        server.ms.delete_organization(org_id=org_id)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+    return org

letta/server/rest_api/routers/v1/sources.py

@@ -0,0 +1,199 @@
+import os
+import tempfile
+from typing import List
+
+from fastapi import APIRouter, BackgroundTasks, Depends, Query, UploadFile
+
+from letta.schemas.document import Document
+from letta.schemas.job import Job
+from letta.schemas.passage import Passage
+from letta.schemas.source import Source, SourceCreate, SourceUpdate
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+# These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
+
+
+router = APIRouter(prefix="/sources", tags=["sources"])
+
+
+@router.get("/{source_id}", response_model=Source, operation_id="get_source")
+def get_source(
+    source_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get all sources
+    """
+    actor = server.get_current_user()
+
+    return server.get_source(source_id=source_id, user_id=actor.id)
+
+
+@router.get("/name/{source_name}", response_model=str, operation_id="get_source_id_by_name")
+def get_source_id_by_name(
+    source_name: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get a source by name
+    """
+    actor = server.get_current_user()
+
+    source_id = server.get_source_id(source_name=source_name, user_id=actor.id)
+    return source_id
+
+
+@router.get("/", response_model=List[Source], operation_id="list_sources")
+def list_sources(
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    List all data sources created by a user.
+    """
+    actor = server.get_current_user()
+
+    return server.list_all_sources(user_id=actor.id)
+
+
+@router.post("/", response_model=Source, operation_id="create_source")
+def create_source(
+    source: SourceCreate,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Create a new data source.
+    """
+    actor = server.get_current_user()
+
+    return server.create_source(request=source, user_id=actor.id)
+
+
+@router.patch("/{source_id}", response_model=Source, operation_id="update_source")
+def update_source(
+    source_id: str,
+    source: SourceUpdate,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Update the name or documentation of an existing data source.
+    """
+    actor = server.get_current_user()
+    assert source.id == source_id, "Source ID in path must match ID in request body"
+
+    return server.update_source(request=source, user_id=actor.id)
+
+
+@router.delete("/{source_id}", response_model=None, operation_id="delete_source")
+def delete_source(
+    source_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Delete a data source.
+    """
+    actor = server.get_current_user()
+
+    server.delete_source(source_id=source_id, user_id=actor.id)
+
+
+@router.post("/{source_id}/attach", response_model=Source, operation_id="attach_agent_to_source")
+def attach_source_to_agent(
+    source_id: str,
+    agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Attach a data source to an existing agent.
+    """
+    actor = server.get_current_user()
+
+    source = server.ms.get_source(source_id=source_id, user_id=actor.id)
+    assert source is not None, f"Source with id={source_id} not found."
+    source = server.attach_source_to_agent(source_id=source.id, agent_id=agent_id, user_id=actor.id)
+    return source
+
+
+@router.post("/{source_id}/detach", response_model=None, operation_id="detach_agent_from_source")
+def detach_source_from_agent(
+    source_id: str,
+    agent_id: str = Query(..., description="The unique identifier of the agent to detach the source from."),
+    server: "SyncServer" = Depends(get_letta_server),
+) -> None:
+    """
+    Detach a data source from an existing agent.
+    """
+    actor = server.get_current_user()
+
+    server.detach_source_from_agent(source_id=source_id, agent_id=agent_id, user_id=actor.id)
+
+
+@router.post("/{source_id}/upload", response_model=Job, operation_id="upload_file_to_source")
+def upload_file_to_source(
+    file: UploadFile,
+    source_id: str,
+    background_tasks: BackgroundTasks,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Upload a file to a data source.
+    """
+    actor = server.get_current_user()
+
+    source = server.ms.get_source(source_id=source_id, user_id=actor.id)
+    assert source is not None, f"Source with id={source_id} not found."
+    bytes = file.file.read()
+
+    # create job
+    job = Job(
+        user_id=actor.id,
+        metadata_={"type": "embedding", "filename": file.filename, "source_id": source_id},
+        completed_at=None,
+    )
+    job_id = job.id
+    server.ms.create_job(job)
+
+    # create background task
+    background_tasks.add_task(load_file_to_source_async, server, source_id=source.id, job_id=job.id, file=file, bytes=bytes)
+
+    # return job information
+    job = server.ms.get_job(job_id=job_id)
+    assert job is not None, "Job not found"
+    return job
+
+
+@router.get("/{source_id}/passages", response_model=List[Passage], operation_id="list_source_passages")
+def list_passages(
+    source_id: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    List all passages associated with a data source.
+    """
+    actor = server.get_current_user()
+    passages = server.list_data_source_passages(user_id=actor.id, source_id=source_id)
+    return passages
+
+
+@router.get("/{source_id}/documents", response_model=List[Document], operation_id="list_source_documents")
+def list_documents(
+    source_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    List all documents associated with a data source.
+    """
+    actor = server.get_current_user()
+
+    documents = server.list_data_source_documents(user_id=actor.id, source_id=source_id)
+    return documents
+
+
+def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, file: UploadFile, bytes: bytes):
+    # write the file to a temporary directory (deleted after the context manager exits)
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        file_path = os.path.join(str(tmpdirname), str(file.filename))
+        with open(file_path, "wb") as buffer:
+            buffer.write(bytes)
+
+        server.load_file_to_source(source_id, file_path, job_id)

letta/server/rest_api/routers/v1/tools.py

@@ -0,0 +1,103 @@
+from typing import List
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+
+from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/tools", tags=["tools"])
+
+
+@router.delete("/{tool_id}", operation_id="delete_tool")
+def delete_tool(
+    tool_id: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Delete a tool by name
+    """
+    # actor = server.get_current_user()
+    server.delete_tool(tool_id=tool_id)
+
+
+@router.get("/{tool_id}", response_model=Tool, operation_id="get_tool")
+def get_tool(
+    tool_id: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Get a tool by ID
+    """
+    # actor = server.get_current_user()
+
+    tool = server.get_tool(tool_id=tool_id)
+    if tool is None:
+        # return 404 error
+        raise HTTPException(status_code=404, detail=f"Tool with id {tool_id} not found.")
+    return tool
+
+
+@router.get("/name/{tool_name}", response_model=str, operation_id="get_tool_id_by_name")
+def get_tool_id(
+    tool_name: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Get a tool ID by name
+    """
+    actor = server.get_current_user()
+
+    tool_id = server.get_tool_id(tool_name, user_id=actor.id)
+    if tool_id is None:
+        # return 404 error
+        raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} not found.")
+    return tool_id
+
+
+@router.get("/", response_model=List[Tool], operation_id="list_tools")
+def list_all_tools(
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Get a list of all tools available to agents created by a user
+    """
+    actor = server.get_current_user()
+    actor.id
+
+    # TODO: add back when user-specific
+    return server.list_tools(user_id=actor.id)
+    # return server.ms.list_tools(user_id=None)
+
+
+@router.post("/", response_model=Tool, operation_id="create_tool")
+def create_tool(
+    tool: ToolCreate = Body(...),
+    update: bool = False,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Create a new tool
+    """
+    actor = server.get_current_user()
+
+    return server.create_tool(
+        request=tool,
+        # update=update,
+        update=True,
+        user_id=actor.id,
+    )
+
+
+@router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
+def update_tool(
+    tool_id: str,
+    request: ToolUpdate = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Update an existing tool
+    """
+    assert tool_id == request.id, "Tool ID in path must match tool ID in request body"
+    server.get_current_user()
+    return server.update_tool(request)

letta/server/rest_api/routers/v1/users.py

@@ -0,0 +1,109 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+
+from letta.schemas.api_key import APIKey, APIKeyCreate
+from letta.schemas.user import User, UserCreate
+from letta.server.rest_api.utils import get_letta_server
+
+# from letta.server.schemas.users import (
+#     CreateAPIKeyRequest,
+#     CreateAPIKeyResponse,
+#     CreateUserRequest,
+#     CreateUserResponse,
+#     DeleteAPIKeyResponse,
+#     DeleteUserResponse,
+#     GetAllUsersResponse,
+#     GetAPIKeysResponse,
+# )
+
+if TYPE_CHECKING:
+    from letta.schemas.user import User
+    from letta.server.server import SyncServer
+
+
+router = APIRouter(prefix="/users", tags=["users", "admin"])
+
+
+@router.get("/", tags=["admin"], response_model=List[User], operation_id="list_users")
+def get_all_users(
+    cursor: Optional[str] = Query(None),
+    limit: Optional[int] = Query(50),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get a list of all users in the database
+    """
+    try:
+        next_cursor, users = server.ms.get_all_users(cursor=cursor, limit=limit)
+        # processed_users = [{"user_id": user.id} for user in users]
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+    return users
+
+
+@router.post("/", tags=["admin"], response_model=User, operation_id="create_user")
+def create_user(
+    request: UserCreate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Create a new user in the database
+    """
+
+    user = server.create_user(request)
+    return user
+
+
+@router.delete("/", tags=["admin"], response_model=User, operation_id="delete_user")
+def delete_user(
+    user_id: str = Query(..., description="The user_id key to be deleted."),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    # 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("/keys", response_model=APIKey, operation_id="create_api_key")
+def create_new_api_key(
+    create_key: APIKeyCreate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Create a new API key for a user
+    """
+    api_key = server.create_api_key(create_key)
+    return api_key
+
+
+@router.get("/keys", response_model=List[APIKey], operation_id="list_api_keys")
+def get_api_keys(
+    user_id: str = Query(..., description="The unique identifier of the user."),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get a list of all API keys for a user
+    """
+    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)
+    return api_keys
+
+
+@router.delete("/keys", response_model=APIKey, operation_id="delete_api_key")
+def delete_api_key(
+    api_key: str = Query(..., description="The API key to be deleted."),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    return server.delete_api_key(api_key)

letta/server/rest_api/static_files.py

@@ -0,0 +1,74 @@
+import importlib.util
+import os
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.staticfiles import StaticFiles
+
+
+class SPAStaticFiles(StaticFiles):
+    async def get_response(self, path: str, scope):
+        try:
+            return await super().get_response(path, scope)
+        except (HTTPException, StarletteHTTPException) as ex:
+            if ex.status_code == 404:
+                return await super().get_response("index.html", scope)
+            else:
+                raise ex
+
+
+def mount_static_files(app: FastAPI):
+    static_files_path = os.path.join(os.path.dirname(importlib.util.find_spec("letta").origin), "server", "static_files")
+    if os.path.exists(static_files_path):
+        app.mount("/assets", StaticFiles(directory=os.path.join(static_files_path, "assets")), name="assets")
+
+        @app.get("/letta_logo_transparent.png", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "letta_logo_transparent.png"))
+
+        @app.get("/", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/agents", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/data-sources", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/tools", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/agent-templates", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/human-templates", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/settings/profile", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+        @app.get("/agents/{agent-id}/chat", include_in_schema=False)
+        async def serve_spa():
+            return FileResponse(os.path.join(static_files_path, "index.html"))
+
+
+# def mount_static_files(app: FastAPI):
+#     static_files_path = os.path.join(os.path.dirname(importlib.util.find_spec("letta").origin), "server", "static_files")
+#     if os.path.exists(static_files_path):
+
+#         @app.get("/{full_path:path}")
+#         async def serve_spa(full_path: str):
+#             if full_path.startswith("v1"):
+#                 raise HTTPException(status_code=404, detail="Not found")
+#             file_path = os.path.join(static_files_path, full_path)
+#             if os.path.isfile(file_path):
+#                 return FileResponse(file_path)
+#             return FileResponse(os.path.join(static_files_path, "index.html"))