# Project export: TimeScribe
This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small.
## Project metadata
- Hackathon: UC Berkeley AI Hackathon 2025
- Tagline: TimeScribe is a digital journal that lets you effortlessly log your thoughts. Using real-time speech transcription and seamless memory storage, TimeScribe can summarize your entire journaling history.
- Devpost: https://devpost.com/software/timescribe-zuv4c0
- GitHub: https://github.com/tednguyen1123/TimeScribe.git
- Video: https://www.youtube.com/embed/45TDC-InK28?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent
- Team: 2 GitHub contributor(s) — Sid Shah (14 commits), Ted Nguyen (13 commits)
## Devpost submission (written by the team)
### Inspiration
wanting to easily log our dreams to keep track of them before we forget them forever helpful for patients dealing with Alzheimer's or any dementia also helpful just for journaling thoughts and ideas that could be accessed later
### What it does
used Groq's blazingly fast latency to easily log users' thoughts by typing them into the text bar or by using the recording feature Because of Groq's speed, our product can quickly summarize and output the logged entries in between the given date range chosen by the user
### How we built it
Used Supabase to store user IDs, agent IDs, and the raw entries for each user Used Groq for STT, TTS, and to summarize the entries Used Letta to add the summarized entries to the context, which is threaded in the background
### Challenges we ran into
At first, we wanted just to use Letta Cloud to store the memory, but it took too long to retrieve the information, so we decided to store the raw data in Supabase instead We had issues trying to connect Groq and Letta, so we decided to manually send the context from Letta to Groq When trying to summarize, the context had a lot of metadata, so we had to manually filter it to only show the text of what the user logged We also ran into problems when trying to send TTS audio back to the frontend, as we did not fully understand how to format and read the HTTP requests.
### Accomplishments we're proud of
We were able to incorporate multimodality, including STT We also incorporated the summarization across customizable date ranges Our product was able to log and summarize the text relatively quickly A user can successfully access their summarized entries even when logging in on another device
### What we learned
How to work with Supabase, a database, to store user information and their data How to use Groq's quick latency to our advantage How to use Groq's whisper model to incorporate STT to transcribe the message to English text, and playai-tts to get the summarized text back to TTS Learned to integrate multiple frameworks and technologies (Groq, Letta, Supabase) Explored threading to run Letta in the background to decrease computational time
### What's next
Proper authentication systems to maintain the privacy of our users
## README (from the GitHub repository)
# TimeScribe
## Detected evidence (automated analysis)
Indexed codebase: 6 recognized source files, 19 KB.
- Flask (technology) — detected in the code
- HTML (language) — detected in the code
- JavaScript (language) — detected in the code
- Python (language) — detected in the code
- Supabase (technology) — detected in the code
## Codebase structure (from repository index)
### Files (8 of 8)
```
.gitignore
README.md
requirements.txt
timescribe-flask-project/app.py
timescribe-flask-project/letta_supabase_standalone.py
timescribe-flask-project/static/script.js
timescribe-flask-project/templates/index.html
timescribe-flask-project/templates/login.html
```
### Dependencies
- requirements.txt: flask, flask_cors, groq, letta-client, supabase
### Recent commits (newest first)
- implemented tts
- Merge branch 'main' of https://github.com/tednguyen1123/TimeScribe
- Small bug fixes
- cleaned up dependencies
- submittable draft including operational summary
- summarizeEntries frontend
- UI small fixes
- incorporated the model and changed the front end
- Letta Responses Arriving (groq not working)
- Merge branch 'main' of https://github.com/tednguyen1123/TimeScribe
- added date buttons
- agent ids implemented into app
- added STT
- added transcribe func
- Frontend Audio recording
- added voicechecker
- frontend changes for voice input
- Login sessions established ACTION: integrate with letta agent
- update requirements for flask_cors
- Merge branch 'main' of https://github.com/tednguyen1123/TimeScribe
## Key source files (fetched from GitHub, selected and truncated for size)
### requirements.txt
```
flask
flask_cors
letta-client
supabase
groq
```
### timescribe-flask-project/app.py
```python
import os, dotenv
import datetime
from flask import Flask, render_template, request, Response, session, redirect, jsonify
from flask_cors import CORS # To handle cross-origin requests
from groq import Groq
from letta_client import Letta, MessageCreate
from supabase import create_client, Client
from threading import Thread
from concurrent.futures import ThreadPoolExecutor
import base64
executor = ThreadPoolExecutor()
dotenv.load_dotenv()
letta_client = Letta(token=os.getenv("LETTA_API_KEY"))
supabase = create_client(
os.getenv("SUPABASE_URL"),
os.getenv("SUPABASE_KEY")
)
groq_client = Groq(
api_key=os.getenv("GROQ_API_KEY"),
)
app = Flask(__name__, template_folder="templates", static_folder="static")
CORS(app) # Allow all domains for now (development only)
app.secret_key = os.getenv("FLASK_SECRET_KEY")
def store_memory(user_id: str, memory_text: str, date: str = None):
supabase.table("Memory").insert({
"user_id": user_id,
"message_text": memory_text,
"timestamp": date if date else datetime.datetime.now().strftime(r"%Y-%m-%d")
}).execute()
def get_memories_range(user_id: str, date_start: str, date_end: str):
result = supabase.table("Memory")\
.select("message_text")\
.eq("user_id", user_id)\
.gte("timestamp", date_start)\
.lte("timestamp", date_end)\
.execute()
return [row["message_text"] for row in result.data]
def message_filter(msg):
if msg.role == "user":
yield msg.content[0].text.content
def recall_context(user_id: str, query: str, letta_client: Letta, supabase, agent_id: str, date_start, date_end, limit=3):
context = []
try:
letta_context = letta_client.agents.context.retrieve(agent_id=agent_id)
# Add core memory
if letta_context.core_memory:
context.append(f"[Memory]\n{letta_context.core_memory}")
# Add summary memory
if letta_context.summary_memory:
context.append(f"[Summary]\n{letta_context.summary_memory}")
# Add external/archival summary
if letta_context.external_memory_summary:
context.append(f"[Long-term Summary]\n{letta_context.external_memory_summary}")
# Add recent messages
for msg in letta_context.messages:
role = msg.role.capitalize()
context.append(f"{role}: {msg.content}")
except Exception as e:
print("Letta memory search error:", e)
try:
supabase_context = get_memories_range(
user_id=user_id,
date_start=date_start,
date_end=date_end
)
context.extend(supabase_context)
except Exception as e:
print("Supabase memory fetch error:", e)
return context
@app.route("/")
def index():
user_id = session.get("user_id")
if not user_id:
return redirect("/login")
else:
print(f"User ID: {user_id} is logged in")
# Check if this user already has an agent
existing = supabase.table("agent_ids").select("*").eq("user_id", user_id).execute()
if existing.data:
agent_id = existing.data[0]['agent_id']
print(f"Agent already exists for {user_id}: {agent_id}")
else:
agent = letta_client.agents.create(
model="anthropic/claude-3-5-haiku",
embedding="openai/text-embedding-3-small",
memory_blocks=[
{"label": "human", "value": f"User name: {user_id}"},
{"label": "persona", "value": "You are a memory journal keeper, helping users track their thoughts and experiences. Only respond with 'logged entry for {date}' when the user inputs a message."}
]
)
agent_id = agent.id
supabase.table("agent_ids").insert({
"user_id": user_id,
"agent_id": agent_id
}).execute()
print(f"Created new agent for {user_id}: {agent_id}")
session["agent_id"] = agent_id
return render_template("index.html")
@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
# Handle login logic here
user_id = request.form.get("user_id")
if user_id:
session["user_id"] = user_id
return redirect("/")
else:
return "Please provide a user ID", 400
# Render a simple login page
else:
return render_template("login.html")
@app.route("/chat", methods=["POST"])
async def chat():
data = request.get_json()
user_input = data.get("message", "")
datetime_now = datetime.datetime.now().strftime(r"%Y-%m-%d")
user_input = f"{datetime_now} \n\n{user_input}"
if not user_input:
return {"error": "No message provided"}, 400
agent_id = session.get("agent_id")
# Wrap synchronous Letta call into coroutine
try:
store_memory(
user_id=session.get("user_id"),
memory_text=user_input,
date=datetime_now
)
# add to letta memory
response = groq_client.chat.completions.create(
model="llama-3.1-8b-instant",
messages=[
{"role": "system", "content": "You are helping people record their memories and thoughts."},
{"role": "user", "content": f"Give me the important details from this, in a short message: {user_input}"}
],
temperature=0.0
)
print(response.choices[0].message.content)
n = datetime.datetime.now()
Thread(target=letta_client.agents.messages.create,kwargs={
"agent_id": agent_id,
"messages": [MessageCreate(
role="user",
content=response.choices[0].message.content
)]}).start()
print(datetime.datetime.now() - n)
except Exception as e:
print("❌ Letta error:", e)
return jsonify({"error": str(e)}),
[truncated — 3145 more characters]
```
### timescribe-flask-project/letta_supabase_standalone.py
```python
import os, dotenv
from letta_client import Letta
from supabase import create_client, Client
dotenv.load_dotenv()
client = Letta(token=os.getenv("LETTA_API_KEY"))
supabase = create_client(
os.getenv("SUPABASE_URL"),
os.getenv("SUPABASE_KEY")
)
name = "Sid" # or from signup/login system
# Check if this user already has an agent
existing = supabase.table("agent_ids").select("*").eq("user_id", name).execute()
if existing.data:
agent_id = existing.data[0]['agent_id']
print(f"Agent already exists for {name}: {agent_id}")
else:
agent = client.agents.create(
model="openai/gpt-4",
embedding="openai/text-embedding-3-small",
memory_blocks=[
{"label": "human", "value": f"User name: {name}"},
{"label": "persona", "value": "You are a memory journal keeper, helping users track their thoughts and experiences."}
]
)
agent_id = agent.id
supabase.table("agent_ids").insert({
"user_id": name,
"agent_id": agent_id
}).execute()
print(f"Created new agent for {name}: {agent_id}")
```
### timescribe-flask-project/templates/login.html
```html
TimeScribe