llmstudio 0.3.2__tar.gz → 0.3.4__tar.gz

{llmstudio-0.3.2 → llmstudio-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llmstudio
-Version: 0.3.2
+Version: 0.3.4
 Summary: Prompt Perfection at Your Fingertips
 Home-page: https://llmstudio.ai/
 License: MIT
@@ -16,7 +16,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: aiohttp (>=3.9.1,<4.0.0)
 Requires-Dist: anthropic (>=0.16.0,<0.17.0)
-Requires-Dist: fastapi (>=0.108.0,<0.109.0)
+Requires-Dist: fastapi (>=0.109.1,<0.110.0)
+Requires-Dist: langchain-experimental (>=0.0.52,<0.0.53)
 Requires-Dist: openai (>=1.6.1,<2.0.0)
 Requires-Dist: pydantic (>=2.5.3,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)

{llmstudio-0.3.2 → llmstudio-0.3.4}/llmstudio/cli.py

@@ -1,35 +1,22 @@
 import os
 import signal
-import socket
 from threading import Thread
 
 import click
 import requests
-from dotenv import load_dotenv
 
+from llmstudio.config import (
+    ENGINE_HOST,
+    ENGINE_PORT,
+    TRACKING_HOST,
+    TRACKING_PORT,
+    UI_HOST,
+    UI_PORT,
+)
 from llmstudio.engine import run_engine_app
 from llmstudio.tracking import run_tracking_app
 from llmstudio.ui import run_ui_app
 
-load_dotenv(os.path.join(os.getcwd(), ".env"))
-
-
-def assign_port():
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("", 0))
-        return s.getsockname()[1]
-
-
-os.environ["LLMSTUDIO_ENGINE_PORT"] = str(assign_port())
-os.environ["NEXT_PUBLIC_LLMSTUDIO_ENGINE_PORT"] = os.environ.get(
-    "LLMSTUDIO_ENGINE_PORT"
-)
-os.environ["LLMSTUDIO_TRACKING_PORT"] = str(assign_port())
-os.environ["NEXT_PUBLIC_LLMSTUDIO_TRACKING_PORT"] = os.environ.get(
-    "LLMSTUDIO_TRACKING_PORT"
-)
-os.environ["LLMSTUDIO_UI_PORT"] = str(assign_port())
-
 
 def is_server_running(host, port, path="/health"):
     try:
@@ -42,16 +29,11 @@ def is_server_running(host, port, path="/health"):
 
 
 def start_server():
-    engine_port = int(os.environ.get("LLMSTUDIO_ENGINE_PORT"))
-    tracking_port = int(os.environ.get("LLMSTUDIO_TRACKING_PORT"))
-    engine_host = os.environ.get("LLMSTUDIO_ENGINE_HOST", "localhost")
-    tracking_host = os.environ.get("LLMSTUDIO_TRACKING_HOST", "localhost")
-
-    if not is_server_running(engine_host, engine_port):
+    if not is_server_running(ENGINE_HOST, ENGINE_PORT):
         engine_thread = Thread(target=run_engine_app, daemon=True)
         engine_thread.start()
 
-    if not is_server_running(tracking_host, tracking_port):
+    if not is_server_running(TRACKING_HOST, TRACKING_PORT):
         tracking_thread = Thread(target=run_tracking_app, daemon=True)
         tracking_thread.start()
 
@@ -77,34 +59,28 @@ def server(ui):
     # Register the signal handler
     signal.signal(signal.SIGINT, handle_shutdown)
 
-    engine_host = os.getenv("LLMSTUDIO_ENGINE_HOST", "localhost")
-    tracking_host = os.getenv("LLMSTUDIO_TRACKING_HOST", "localhost")
-    engine_port = int(os.getenv("LLMSTUDIO_ENGINE_PORT"))
-    tracking_port = int(os.getenv("LLMSTUDIO_TRACKING_PORT"))
-
     # Start the engine if it's not already running
-    if not is_server_running(engine_host, engine_port):
+    if not is_server_running(ENGINE_HOST, ENGINE_PORT):
         engine_thread = Thread(target=run_engine_app, daemon=True)
         engine_thread.start()
     else:
-        print(f"Engine server already running on {engine_host}:{engine_port}")
+        print(f"Engine server already running on {ENGINE_HOST}:{ENGINE_PORT}")
 
     # Start the tracking if it's not already running
-    if not is_server_running(tracking_host, tracking_port):
+    if not is_server_running(TRACKING_HOST, TRACKING_PORT):
         tracking_thread = Thread(target=run_tracking_app, daemon=True)
         tracking_thread.start()
     else:
-        print(f"Tracking server already running on {tracking_host}:{tracking_port}")
+        print(f"Tracking server already running on {TRACKING_HOST}:{TRACKING_PORT}")
 
     # Start the UI if requested and not already running
     if ui:
-        ui_port = int(os.getenv("LLMSTUDIO_UI_PORT"))
-        if not is_server_running("localhost", ui_port):
+        if not is_server_running(UI_HOST, UI_PORT):
             ui_thread = Thread(target=run_ui_app, daemon=True)
             ui_thread.start()
             ui_thread.join()
         else:
-            print(f"UI server already running on localhost:{ui_port}")
+            print(f"UI server already running on {UI_HOST}:{UI_PORT}")
 
     if engine_thread:
         engine_thread.join()

llmstudio-0.3.4/llmstudio/config.py

@@ -0,0 +1,47 @@
+import os
+import socket
+
+from dotenv import load_dotenv
+
+load_dotenv(os.path.join(os.getcwd(), ".env"))
+
+
+def assign_port(default_port=None):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            if default_port is not None:
+                s.bind(("", default_port))
+                return default_port
+            else:
+                s.bind(("", 0))
+                return s.getsockname()[1]
+        except OSError:
+            s.bind(("", 0))
+            return s.getsockname()[1]
+
+
+defaults = {
+    "LLMSTUDIO_ENGINE_HOST": "localhost",
+    "LLMSTUDIO_TRACKING_HOST": "localhost",
+    "LLMSTUDIO_UI_HOST": "localhost",
+    "LLMSTUDIO_ENGINE_PORT": str(assign_port(50001)),
+    "LLMSTUDIO_TRACKING_PORT": str(assign_port(50002)),
+    "LLMSTUDIO_UI_PORT": str(assign_port(50003)),
+    "LLMSTUDIO_TRACKING_URI": "sqlite:///./llmstudio_mgmt.db",
+}
+
+for key, default in defaults.items():
+    os.environ[key] = os.getenv(key, default)
+
+ENGINE_PORT = os.environ["LLMSTUDIO_ENGINE_PORT"]
+TRACKING_PORT = os.environ["LLMSTUDIO_TRACKING_PORT"]
+UI_PORT = os.environ["LLMSTUDIO_UI_PORT"]
+ENGINE_HOST = os.environ["LLMSTUDIO_ENGINE_HOST"]
+TRACKING_HOST = os.environ["LLMSTUDIO_TRACKING_HOST"]
+UI_HOST = os.environ["LLMSTUDIO_UI_HOST"]
+TRACKING_URI = os.environ["LLMSTUDIO_TRACKING_URI"]
+
+os.environ["NEXT_PUBLIC_LLMSTUDIO_ENGINE_PORT"] = ENGINE_PORT
+os.environ["NEXT_PUBLIC_LLMSTUDIO_TRACKING_PORT"] = TRACKING_PORT
+os.environ["NEXT_PUBLIC_LLMSTUDIO_ENGINE_HOST"] = ENGINE_HOST
+os.environ["NEXT_PUBLIC_LLMSTUDIO_TRACKING_HOST"] = TRACKING_HOST

{llmstudio-0.3.2 → llmstudio-0.3.4}/llmstudio/engine/__init__.py

@@ -3,7 +3,6 @@ import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-import requests
 import uvicorn
 import yaml
 from fastapi import FastAPI, Request
@@ -11,6 +10,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, ValidationError
 
+from llmstudio.config import ENGINE_HOST, ENGINE_PORT
 from llmstudio.engine.providers import *
 
 ENGINE_BASE_ENDPOINT = "/api/engine"
@@ -160,19 +160,21 @@ def create_engine_app(config: EngineConfig = _load_engine_config()) -> FastAPI:
             iter([csv_content]), media_type="text/csv", headers=headers
         )
 
+    @app.on_event("startup")
+    async def startup_event():
+        print(f"Running LLMstudio Engine on http://{ENGINE_HOST}:{ENGINE_PORT} ")
+
     return app
 
 
 def run_engine_app():
-    print(
-        f"Running Engine on http://{os.getenv('LLMSTUDIO_ENGINE_HOST')}:{os.getenv('LLMSTUDIO_ENGINE_PORT')}"
-    )
     try:
         engine = create_engine_app()
         uvicorn.run(
             engine,
-            host=os.getenv("LLMSTUDIO_ENGINE_HOST"),
-            port=int(os.getenv("LLMSTUDIO_ENGINE_PORT")),
+            host=ENGINE_HOST,
+            port=ENGINE_PORT,
+            log_level="warning",
         )
     except Exception as e:
-        print(f"Error running the Engine app: {e}")
+        print(f"Error running LLMstudio Engine: {e}")

{llmstudio-0.3.2 → llmstudio-0.3.4}/llmstudio/engine/providers/azure.py

@@ -4,9 +4,10 @@ from typing import Any, AsyncGenerator, Coroutine, Dict, Generator, List, Option
 
 import openai
 from fastapi import HTTPException
-from openai import AzureOpenAI
+from openai import AzureOpenAI, OpenAI
 from pydantic import BaseModel, Field
 
+
 from llmstudio.engine.providers.provider import ChatRequest, Provider, provider
 
 
@@ -21,6 +22,7 @@ class AzureParameters(BaseModel):
 class AzureRequest(ChatRequest):
     api_endpoint: Optional[str] = None
     api_version: Optional[str] = None
+    base_url: Optional[str] = None
     parameters: Optional[AzureParameters] = AzureParameters()
     functions: Optional[List[Dict[str, Any]]] = None
     chat_input: Any
@@ -33,6 +35,7 @@ class AzureProvider(Provider):
         self.API_KEY = os.getenv("AZURE_API_KEY")
         self.API_ENDPOINT = os.getenv("AZURE_API_ENDPOINT")
         self.API_VERSION = os.getenv("AZURE_API_VERSION")
+        self.BASE_URL = os.getenv("AZURE_BASE_URL")
 
     def validate_request(self, request: AzureRequest):
         return AzureRequest(**request)
@@ -42,24 +45,41 @@ class AzureProvider(Provider):
     ) -> Coroutine[Any, Any, Generator]:
         """Generate an AzureOpenAI client"""
         try:
-            client = AzureOpenAI(
-                api_key=request.api_key or self.API_KEY,
-                azure_endpoint=request.api_endpoint or self.API_ENDPOINT,
-                api_version=request.api_version or self.API_VERSION,
-            )
-            return await asyncio.to_thread(
-                client.chat.completions.create,
-                model=request.model,
-                messages=(
-                    [{"role": "user", "content": request.chat_input}]
-                    if isinstance(request.chat_input, str)
-                    else request.chat_input
-                ),
-                functions=request.functions,
-                function_call="auto" if request.functions else None,
-                stream=True,
-                **request.parameters.model_dump(),
-            )
+            if request.api_endpoint or self.API_ENDPOINT:
+                client = AzureOpenAI(
+                    api_key=request.api_key or self.API_KEY,
+                    azure_endpoint=request.api_endpoint or self.API_ENDPOINT,
+                    api_version=request.api_version or self.API_VERSION,
+                )
+                return await asyncio.to_thread(
+                    client.chat.completions.create,
+                    model=request.model,
+                    messages=(
+                        [{"role": "user", "content": request.chat_input}]
+                        if isinstance(request.chat_input, str)
+                        else request.chat_input
+                    ),
+                    functions=request.functions,
+                    function_call="auto" if request.functions else None,
+                    stream=True,
+                    **request.parameters.model_dump(),
+                )
+            elif request.base_url or self.BASE_URL:
+                client = OpenAI(
+                    api_key=request.api_key or self.API_KEY,
+                    base_url=request.base_url or self.BASE_URL,
+                )
+                return await asyncio.to_thread(
+                    client.chat.completions.create,
+                    model=request.model,
+                    messages=(
+                        [{"role": "user", "content": request.chat_input}]
+                        if isinstance(request.chat_input, str)
+                        else request.chat_input
+                    ),
+                    stream=True,
+                )
+
         except openai._exceptions.APIError as e:
             raise HTTPException(status_code=e.status_code, detail=e.response.json())
 

{llmstudio-0.3.2 → llmstudio-0.3.4}/llmstudio/engine/providers/provider.py

@@ -211,6 +211,9 @@ class Provider:
             function_calls = [
                 chunk.get("choices")[0].get("delta").get("function_call")
                 for chunk in chunks[1:-1]
+                if chunk.get("choices")
+                and chunk.get("choices")[0].get("delta")
+                and chunk.get("choices")[0].get("delta").get("function_call")
             ]
 
             if isinstance(request, AzureRequest):

{llmstudio-0.3.2 → llmstudio-0.3.4}/llmstudio/llm/__init__.py

@@ -1,10 +1,9 @@
-import os
-
 import aiohttp
 import requests
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 
 from llmstudio.cli import start_server
+from llmstudio.config import ENGINE_HOST, ENGINE_PORT
 
 
 class LLM:
@@ -15,6 +14,7 @@ class LLM:
         self.api_key = kwargs.get("api_key")
         self.api_endpoint = kwargs.get("api_endpoint")
         self.api_version = kwargs.get("api_version")
+        self.base_url = kwargs.get("base_url")
         self.temperature = kwargs.get("temperature")
         self.top_p = kwargs.get("top_p")
         self.top_k = kwargs.get("top_k")
@@ -22,13 +22,14 @@ class LLM:
 
     def chat(self, input: str, is_stream: bool = False, **kwargs):
         response = requests.post(
-            f"http://{os.getenv('LLMSTUDIO_ENGINE_HOST')}:{os.getenv('LLMSTUDIO_ENGINE_PORT')}/api/engine/chat/{self.provider}",
+            f"http://{ENGINE_HOST}:{ENGINE_PORT}/api/engine/chat/{self.provider}",
             json={
                 "model": self.model,
                 "session_id": self.session_id,
                 "api_key": self.api_key,
                 "api_endpoint": self.api_endpoint,
                 "api_version": self.api_version,
+                "base_url": self.base_url,
                 "chat_input": input,
                 "is_stream": is_stream,
                 "parameters": {
@@ -64,7 +65,7 @@ class LLM:
     async def async_non_stream(self, input: str, **kwargs):
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{os.getenv('LLMSTUDIO_ENGINE_HOST')}:{os.getenv('LLMSTUDIO_ENGINE_PORT')}/api/engine/chat/{self.provider}",
+                f"http://{ENGINE_HOST}:{ENGINE_PORT}/api/engine/chat/{self.provider}",
                 json={
                     "model": self.model,
                     "api_key": self.api_key,
@@ -78,12 +79,12 @@ class LLM:
             ) as response:
                 response.raise_for_status()
 
-                return await ChatCompletion(**response.json())
+                return ChatCompletion(**await response.json())
 
     async def async_stream(self, input: str, **kwargs):
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{os.getenv('LLMSTUDIO_ENGINE_HOST')}:{os.getenv('LLMSTUDIO_ENGINE_PORT')}/api/engine/chat/{self.provider}",
+                f"http://{ENGINE_HOST}:{ENGINE_PORT}/api/engine/chat/{self.provider}",
                 json={
                     "model": self.model,
                     "api_key": self.api_key,
@@ -99,4 +100,4 @@ class LLM:
 
                 async for chunk in response.content.iter_any():
                     if chunk:
-                        yield ChatCompletionChunk(**chunk.decode("utf-8"))
+                        yield ChatCompletionChunk(**await chunk.decode("utf-8"))

{llmstudio-0.3.2 → llmstudio-0.3.4}/llmstudio/llm/langchain.py

@@ -46,7 +46,7 @@ class ChatLLMstudio(BaseChatModel):
         token_usage = response.get("usage", {})
         llm_output = {
             "token_usage": token_usage,
-            "model_name": "gpt-4-32k",  # self.model_name,
+            "model_name": response["model"],
             "system_fingerprint": response.get("system_fingerprint", ""),
         }
         return ChatResult(generations=generations, llm_output=llm_output)

llmstudio-0.3.4/llmstudio/tracking/__init__.py

@@ -0,0 +1,64 @@
+import uvicorn
+from fastapi import APIRouter, FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from llmstudio.config import TRACKING_HOST, TRACKING_PORT
+from llmstudio.engine.providers import *
+from llmstudio.tracking.logs.endpoints import LogsRoutes
+from llmstudio.tracking.session.endpoints import SessionsRoutes
+
+TRACKING_HEALTH_ENDPOINT = "/health"
+TRACKING_TITLE = "LLMstudio Tracking API"
+TRACKING_DESCRIPTION = "The tracking API for LLM interactions"
+TRACKING_VERSION = "0.0.1"
+TRACKING_BASE_ENDPOINT = "/api/tracking"
+
+## Tracking
+def create_tracking_app() -> FastAPI:
+    app = FastAPI(
+        title=TRACKING_TITLE,
+        description=TRACKING_DESCRIPTION,
+        version=TRACKING_VERSION,
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @app.get(TRACKING_HEALTH_ENDPOINT)
+    def health_check():
+        """Health check endpoint to ensure the API is running."""
+        return {"status": "healthy", "message": "Tracking is up and running"}
+
+    tracking_router = APIRouter(prefix=TRACKING_BASE_ENDPOINT)
+    LogsRoutes(tracking_router)
+    SessionsRoutes(tracking_router)
+
+    app.include_router(tracking_router)
+
+    @app.on_event("startup")
+    async def startup_event():
+        print(f"Running LLMstudio Tracking on http://{TRACKING_HOST}:{TRACKING_PORT} ")
+
+    return app
+
+
+def run_tracking_app():
+    try:
+        tracking = create_tracking_app()
+        uvicorn.run(
+            tracking,
+            host=TRACKING_HOST,
+            port=TRACKING_PORT,
+            log_level="warning",
+        )
+    except Exception as e:
+        print(f"Error running LLMstudio Tracking: {e}")
+
+
+if __name__ == "__main__":
+    run_tracking_app()

llmstudio-0.3.4/llmstudio/tracking/database.py

@@ -0,0 +1,25 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+from llmstudio.config import TRACKING_URI
+
+
+def create_tracking_engine(uri: str):
+    if uri.split("://")[0] == "sqlite":
+        return create_engine(uri, connect_args={"check_same_thread": False})
+    return create_engine(uri)
+
+
+engine = create_tracking_engine(TRACKING_URI)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

{llmstudio-0.3.2/llmstudio/tracking → llmstudio-0.3.4/llmstudio/tracking/logs}/crud.py

@@ -1,6 +1,6 @@
 from sqlalchemy.orm import Session
 
-from llmstudio.tracking import models, schemas
+from llmstudio.tracking.logs import models, schemas
 
 
 def get_project_by_name(db: Session, name: str):
@@ -22,6 +22,7 @@ def add_log(db: Session, log: schemas.LogDefaultCreate):
     db.add(db_log)
     db.commit()
     db.refresh(db_log)
+
     return db_log
 
 

llmstudio-0.3.4/llmstudio/tracking/logs/endpoints.py

@@ -0,0 +1,57 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from llmstudio.tracking.database import engine, get_db
+from llmstudio.tracking.logs import crud, models, schemas
+
+models.Base.metadata.create_all(bind=engine)
+
+
+class LogsRoutes:
+    def __init__(self, router: APIRouter):
+        self.router = router
+
+        # Define routes
+        self.define_routes()
+
+    def define_routes(self):
+        # Add log
+        self.router.post(
+            "/logs",
+            response_model=schemas.LogDefault,
+        )(self.add_log)
+
+        # Read logs
+        self.router.get("/logs", response_model=List[schemas.LogDefault])(
+            self.read_logs
+        )
+
+        # Read logs by session
+        self.router.get("/logs_by_session", response_model=List[schemas.LogDefault])(
+            self.read_logs_by_session
+        )
+
+    async def add_log(
+        self, log: schemas.LogDefaultCreate, db: Session = Depends(get_db)
+    ):
+        return crud.add_log(db=db, log=log)
+
+    async def read_logs(
+        self, skip: int = 0, limit: int = 1000, db: Session = Depends(get_db)
+    ):
+        logs = crud.get_logs(db, skip=skip, limit=limit)
+        return logs
+
+    async def read_logs_by_session(
+        self,
+        session_id: str,
+        skip: int = 0,
+        limit: int = 1000,
+        db: Session = Depends(get_db),
+    ):
+        logs = crud.get_logs_by_session(
+            db, session_id=session_id, skip=skip, limit=limit
+        )
+        return logs

{llmstudio-0.3.2/llmstudio/tracking → llmstudio-0.3.4/llmstudio/tracking/logs}/models.py

@@ -1,5 +1,4 @@
-from sqlalchemy import JSON, Boolean, Column, DateTime, ForeignKey, Integer, String
-from sqlalchemy.orm import relationship
+from sqlalchemy import JSON, Column, DateTime, Integer, String
 from sqlalchemy.sql import func
 
 from llmstudio.tracking.database import Base

llmstudio-0.3.4/llmstudio/tracking/session/crud.py

@@ -0,0 +1,49 @@
+from sqlalchemy.orm import Session
+
+from llmstudio.tracking.session import models, schemas
+
+
+def get_project_by_name(db: Session, name: str):
+    return db.query(models.Project).filter(models.Project.name == name).first()
+
+
+def get_session_by_session_id(
+    db: Session, session_id: str, skip: int = 0, limit: int = 100
+):
+    return (
+        db.query(models.SessionDefault)
+        .filter(models.SessionDefault.session_id == session_id)
+        .order_by(models.SessionDefault.created_at.asc())
+        .offset(skip)
+        .limit(limit)
+        .all()
+    )
+
+
+def get_session_by_message_id(db: Session, message_id: int):
+    return (
+        db.query(models.SessionDefault)
+        .filter(models.SessionDefault.message_id == message_id)
+        .first()
+    )
+
+
+def add_session(db: Session, session: schemas.SessionDefaultCreate):
+    db_session = models.SessionDefault(**session.dict())
+
+    db.add(db_session)
+    db.commit()
+    db.refresh(db_session)
+    return db_session
+
+
+def update_session(db: Session, message_id: int, extras: dict):
+    existing_session = get_session_by_message_id(db, message_id)
+    existing_session.extras = extras
+    db.commit()
+    db.refresh(existing_session)
+    return existing_session
+
+
+def upsert_session(db: Session, session: schemas.SessionDefaultCreate):
+    return add_session(db, session)

llmstudio-0.3.4/llmstudio/tracking/session/endpoints.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from llmstudio.tracking.database import engine, get_db
+from llmstudio.tracking.session import crud, models, schemas
+
+models.Base.metadata.create_all(bind=engine)
+
+
+class SessionsRoutes:
+    def __init__(self, router: APIRouter):
+        self.router = router
+        self.define_routes()
+
+    def define_routes(self):
+        # Add session
+        self.router.post(
+            "/session",
+            response_model=schemas.SessionDefault,
+        )(self.add_session)
+
+        # Read session
+        self.router.get(
+            "/session/{session_id}", response_model=List[schemas.SessionDefault]
+        )(self.get_session)
+
+        self.router.patch(
+            "/session/{message_id}", response_model=schemas.SessionDefault
+        )(self.update_session)
+
+    async def add_session(
+        self, session: schemas.SessionDefaultCreate, db: Session = Depends(get_db)
+    ):
+        return crud.upsert_session(db=db, session=session)
+
+    async def update_session(
+        self, message_id: int, extras: dict, db: Session = Depends(get_db)
+    ):
+        sessions = crud.update_session(db, message_id=message_id, extras=extras)
+        return sessions
+
+    async def get_session(self, session_id: str, db: Session = Depends(get_db)):
+        sessions = crud.get_session_by_session_id(db, session_id=session_id)
+        return sessions