App-Based Examples

pip install memori openai fastapi uvicorn

import os
from fastapi import FastAPI
from pydantic import BaseModel
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

app = FastAPI()

engine = create_engine("sqlite:///memori.db", connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(bind=engine)
Memori(conn=SessionLocal).config.storage.build()

class ChatRequest(BaseModel):
    message: str

@app.post("/chat/{user_id}")
def chat(user_id: str, req: ChatRequest):
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    mem = Memori(conn=SessionLocal).llm.register(client)
    mem.attribution(entity_id=user_id, process_id="fastapi_chat")

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": req.message}]
    )
    return {"response": response.choices[0].message.content}

@app.get("/recall/{user_id}")
def recall(user_id: str, query: str):
    mem = Memori(conn=SessionLocal)
    mem.attribution(entity_id=user_id, process_id="fastapi_chat")
    return {"facts": mem.recall(query, limit=5)}

pip install memori openai flask

import os
from flask import Flask, request, jsonify
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

def create_app():
    app = Flask(__name__)
    engine = create_engine("sqlite:///memori.db")
    SessionLocal = sessionmaker(bind=engine)
    Memori(conn=SessionLocal).config.storage.build()

    @app.route("/chat", methods=["POST"])
    def chat():
        data = request.get_json()
        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        mem = Memori(conn=SessionLocal).llm.register(client)
        mem.attribution(entity_id=data["user_id"], process_id="flask_chat")

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": data["message"]}]
        )
        return jsonify({"response": response.choices[0].message.content})

    @app.route("/recall", methods=["GET"])
    def recall():
        mem = Memori(conn=SessionLocal)
        mem.attribution(entity_id=request.args["user_id"], process_id="flask_chat")
        return jsonify({"facts": mem.recall(request.args["query"], limit=5)})

    return app

pip install memori openai django

# settings.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

MEMORI_ENGINE = create_engine("sqlite:///memori.db")
MEMORI_SESSION = sessionmaker(bind=MEMORI_ENGINE)

# views.py
import os, json
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.conf import settings
from memori import Memori
from openai import OpenAI

Memori(conn=settings.MEMORI_SESSION).config.storage.build()

@csrf_exempt
def chat(request):
    data = json.loads(request.body)
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    mem = Memori(conn=settings.MEMORI_SESSION).llm.register(client)
    mem.attribution(entity_id=str(request.user.id), process_id="django_chat")

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": data["message"]}]
    )
    return JsonResponse({"response": response.choices[0].message.content})