Upload folder using huggingface_hub

.aws/task-definition-production.json

@@ -0,0 +1,95 @@
+{
+  "taskDefinitionArn": "arn:aws:ecs:ap-southeast-1:537124935427:task-definition/production-ourcoach-ai-core:1",
+  "containerDefinitions": [
+      {
+          "name": "ourcoach-ai-core",
+          "image": "537124935427.dkr.ecr.ap-southeast-1.amazonaws.com/production/ourcoach-ai-core",
+          "cpu": 256,
+          "memory": 512,
+          "portMappings": [
+              {
+                  "name": "7860",
+                  "containerPort": 7860,
+                  "hostPort": 7860,
+                  "protocol": "tcp",
+                  "appProtocol": "http"
+              }
+          ],
+          "essential": true,
+          "environment": [],
+          "environmentFiles": [],
+          "mountPoints": [],
+          "volumesFrom": [],
+          "ulimits": [],
+          "logConfiguration": {
+              "logDriver": "awslogs",
+              "options": {
+                  "awslogs-group": "/ecs/production-ourcoach-ai-core",
+                  "mode": "non-blocking",
+                  "awslogs-create-group": "true",
+                  "max-buffer-size": "25m",
+                  "awslogs-region": "ap-southeast-1",
+                  "awslogs-stream-prefix": "ecs"
+              },
+              "secretOptions": []
+          },
+          "systemControls": []
+      }
+  ],
+  "family": "production-ourcoach-ai-core",
+  "taskRoleArn": "arn:aws:iam::537124935427:role/ecsTaskExecutionRole",
+  "executionRoleArn": "arn:aws:iam::537124935427:role/ecsTaskExecutionRole",
+  "networkMode": "awsvpc",
+  "revision": 1,
+  "volumes": [],
+  "status": "ACTIVE",
+  "requiresAttributes": [
+      {
+          "name": "com.amazonaws.ecs.capability.logging-driver.awslogs"
+      },
+      {
+          "name": "ecs.capability.execution-role-awslogs"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.ecr-auth"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.28"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.task-iam-role"
+      },
+      {
+          "name": "ecs.capability.execution-role-ecr-pull"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
+      },
+      {
+          "name": "ecs.capability.task-eni"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.29"
+      }
+  ],
+  "placementConstraints": [],
+  "compatibilities": [
+      "EC2",
+      "FARGATE"
+  ],
+  "requiresCompatibilities": [
+      "FARGATE"
+  ],
+  "cpu": "256",
+  "memory": "512",
+  "runtimePlatform": {
+      "cpuArchitecture": "X86_64",
+      "operatingSystemFamily": "LINUX"
+  },
+  "registeredAt": "2024-10-31T06:16:27.129Z",
+  "registeredBy": "arn:aws:iam::537124935427:user/besher",
+  "tags": []
+}

.aws/task-definition-staging.json

@@ -0,0 +1,95 @@
+{
+  "taskDefinitionArn": "arn:aws:ecs:ap-southeast-1:537124935427:task-definition/staging-ourcoach-ai-core:1",
+  "containerDefinitions": [
+      {
+          "name": "ourcoach-ai-core",
+          "image": "537124935427.dkr.ecr.ap-southeast-1.amazonaws.com/staging/ourcoach-ai-core",
+          "cpu": 256,
+          "memory": 512,
+          "portMappings": [
+              {
+                  "name": "7860",
+                  "containerPort": 7860,
+                  "hostPort": 7860,
+                  "protocol": "tcp",
+                  "appProtocol": "http"
+              }
+          ],
+          "essential": true,
+          "environment": [],
+          "environmentFiles": [],
+          "mountPoints": [],
+          "volumesFrom": [],
+          "ulimits": [],
+          "logConfiguration": {
+              "logDriver": "awslogs",
+              "options": {
+                  "awslogs-group": "/ecs/staging-ourcoach-ai-core",
+                  "mode": "non-blocking",
+                  "awslogs-create-group": "true",
+                  "max-buffer-size": "25m",
+                  "awslogs-region": "ap-southeast-1",
+                  "awslogs-stream-prefix": "ecs"
+              },
+              "secretOptions": []
+          },
+          "systemControls": []
+      }
+  ],
+  "family": "staging-ourcoach-ai-core",
+  "taskRoleArn": "arn:aws:iam::537124935427:role/ecsTaskExecutionRole",
+  "executionRoleArn": "arn:aws:iam::537124935427:role/ecsTaskExecutionRole",
+  "networkMode": "awsvpc",
+  "revision": 1,
+  "volumes": [],
+  "status": "ACTIVE",
+  "requiresAttributes": [
+      {
+          "name": "com.amazonaws.ecs.capability.logging-driver.awslogs"
+      },
+      {
+          "name": "ecs.capability.execution-role-awslogs"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.ecr-auth"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.28"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.task-iam-role"
+      },
+      {
+          "name": "ecs.capability.execution-role-ecr-pull"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
+      },
+      {
+          "name": "ecs.capability.task-eni"
+      },
+      {
+          "name": "com.amazonaws.ecs.capability.docker-remote-api.1.29"
+      }
+  ],
+  "placementConstraints": [],
+  "compatibilities": [
+      "EC2",
+      "FARGATE"
+  ],
+  "requiresCompatibilities": [
+      "FARGATE"
+  ],
+  "cpu": "256",
+  "memory": "512",
+  "runtimePlatform": {
+      "cpuArchitecture": "X86_64",
+      "operatingSystemFamily": "LINUX"
+  },
+  "registeredAt": "2024-10-25T11:56:36.943Z",
+  "registeredBy": "arn:aws:iam::537124935427:user/besher",
+  "tags": []
+}

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY='sk-svcacct-ogaRpJ1DnTAqXmfM5E-omC1FqcLkRCgfaJsY62YaNV-gHb74FJu9XUizZoTCjqpT3BlbkFJEu3xXX4JEIg3K-L8DB3GUX4RVZMvUXrnJE2tcrgzlTnv4YGj_12b3hcUNSl38AA'

.github/workflows/deploy-production.yml

@@ -0,0 +1,23 @@
+name: Deployment Pipeline (Production)
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  id-token: write # This is required for requesting the JWT
+  contents: read # This is required for actions/checkout
+
+jobs:
+  deploy:
+    name: Using Deployment Workflow
+    uses: ./.github/workflows/deployment.yml
+    with:
+      active_env: production
+      ecr_url: 537124935427.dkr.ecr.ap-southeast-1.amazonaws.com/production/ourcoach-ai-core
+      ecs_service: ourcoach-ai-core
+      ecs_cluster: ProductionECSCluster
+      ecs_task_definition: .aws/task-definition-production.json
+      container_name: ourcoach-ai-core
+    secrets: inherit

.github/workflows/deploy-staging.yml

@@ -0,0 +1,23 @@
+name: Deployment Pipeline (Staging)
+
+on:
+  push:
+    branches:
+      - staging
+
+permissions:
+  id-token: write # This is required for requesting the JWT
+  contents: read # This is required for actions/checkout
+
+jobs:
+  deploy:
+    name: Using Deployment Workflow
+    uses: ./.github/workflows/deployment.yml
+    with:
+      active_env: staging
+      ecr_url: 537124935427.dkr.ecr.ap-southeast-1.amazonaws.com/staging/ourcoach-ai-core
+      ecs_service: ourcoach-ai-core
+      ecs_cluster: StagingECSCluster
+      ecs_task_definition: .aws/task-definition-staging.json
+      container_name: ourcoach-ai-core
+    secrets: inherit

.github/workflows/deployment.yml

@@ -0,0 +1,76 @@
+name: Reusable Deployment Workflow
+
+on:
+  workflow_call:
+    inputs:
+      active_env:
+        required: true
+        type: string
+      ecr_url:
+        required: true
+        type: string
+      ecs_service:
+        required: true
+        type: string
+      ecs_cluster:
+        required: true
+        type: string
+      ecs_task_definition:
+        required: true
+        type: string
+      container_name:
+        required: true
+        type: string
+
+env:
+  AWS_REGION: ap-southeast-1
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    environment:
+      name: ${{ inputs.active_env }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          IMAGE_TAG: ${{ github.sha }}
+        run: |
+          docker build --build-arg FASTAPI_KEY=${{secrets.FASTAPI_KEY}} --build-arg OPENAI_API_KEY=${{secrets.OPENAI_API_KEY}} -t ${{inputs.ecr_url}}:$IMAGE_TAG .
+          docker push ${{inputs.ecr_url}}:$IMAGE_TAG
+          echo "image=${{inputs.ecr_url}}:$IMAGE_TAG" >> $GITHUB_OUTPUT
+
+      - name: Fill in the new image ID in the Amazon ECS task definition
+        id: task-def
+        uses: aws-actions/amazon-ecs-render-task-definition@c804dfbdd57f713b6c079302a4c01db7017a36fc
+        with:
+          task-definition: ${{ inputs.ecs_task_definition }}
+          container-name: ${{ inputs.container_name }}
+          image: ${{ steps.build-image.outputs.image }}
+
+      - name: Deploy Amazon ECS task definition
+        uses: aws-actions/amazon-ecs-deploy-task-definition@df9643053eda01f169e64a0e60233aacca83799a
+        with:
+          task-definition: ${{ steps.task-def.outputs.task-definition }}
+          service: ${{ inputs.ecs_service }}
+          cluster: ${{ inputs.ecs_cluster }}
+          wait-for-service-stability: true

.gitignore

@@ -0,0 +1,2 @@
+templates/
+personalfinance_wiki/

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

Dockerfile

@@ -0,0 +1,26 @@
+# Use the official Python 3.10.9 image
+FROM python:3.10.9
+
+# Expose the port FastAPI will run on
+EXPOSE 7860
+
+# Set environment variables for FastAPI and OpenAI API keys
+ARG FASTAPI_KEY
+ARG OPENAI_API_KEY
+
+ENV FASTAPI_KEY=$FASTAPI_KEY
+ENV OPENAI_API_KEY=$OPENAI_API_KEY
+ENV PYTHONUNBUFFERED=1
+
+# Set the working directory
+WORKDIR /code
+
+# Copy requirements and install dependencies
+COPY ./app/requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copy the app directory
+COPY ./app /code/app
+
+# Start the FastAPI app on port 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,8 @@
----
-title: Demo1
-emoji: 📈
-colorFrom: blue
-colorTo: gray
-sdk: gradio
-sdk_version: 5.6.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Demo1
+app_file: demo.py
+sdk: gradio
+sdk_version: 5.3.0
+---
+# ourcoach-ai-core
+Contains all AI system

app/main.py

@@ -0,0 +1,462 @@
+from fastapi import FastAPI, HTTPException, Security, Query, status
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel
+from uuid import UUID
+import os
+import logging
+import json 
+from datetime import datetime
+from langchain.chat_models import ChatOpenAI
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from typing import List, Optional
+
+# Environment Variables for API Keys
+api_keys = [os.getenv('FASTAPI_KEY')]
+api_key_header = APIKeyHeader(name="X-API-Key")
+
+def get_api_key(api_key_header: str = Security(api_key_header)) -> str:
+    if api_key_header in api_keys:
+        return api_key_header
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid or missing API Key",
+    )
+
+# Initialize Logging (optional)
+# logging.basicConfig(filename='app.log', level=logging.INFO)
+
+# OpenAI GPT Wrapper
+llm = ChatOpenAI(temperature=0.85, model='gpt-4o-mini', api_key=os.getenv('OPENAI_API_KEY'), max_tokens=300)
+
+# FastAPI App
+app = FastAPI(title="Ourcoach AI API", description="A FastAPI app for ourcoach's chatbot", version="0.1.0")
+
+# Pydantic Models
+class HistoryItem(BaseModel):
+    role: str
+    content: str
+
+class SummaryItem(BaseModel):
+    summary: str
+    date: str
+
+class ChatRequest(BaseModel):
+    message: str
+    history: List[HistoryItem]
+    name: str
+    birthday: str
+    country: str
+    perfect_day: str
+    focus: str
+    goals: str
+    challenges: str
+    email_address: str
+    whatsapp_number: str
+    belief_in_astrology: str
+    legendary_persona: str
+    latest_summary: Optional[str] = None
+
+class SummaryRequest(BaseModel):
+    history: List[HistoryItem]
+    name: str
+    birthday: str
+    country: str
+    perfect_day: str
+    focus: str
+    goals: str
+    challenges: str
+    email_address: str
+    whatsapp_number: str
+    belief_in_astrology: str
+    legendary_persona: str
+    latest_summary: Optional[str] = None
+
+class NewsLetterRequest(BaseModel):
+    summaries: List[SummaryItem]
+
+@app.get("/ok")
+def ok_endpoint():
+    return {"message": "ok"}
+
+@app.post("/chat")
+def predict(request: ChatRequest, api_key: str = Security(get_api_key)):
+    bot_name = request.legendary_persona.split(' ')[0]
+
+    # Retrieve the latest summary for this user_id
+    summary = request.latest_summary
+
+    # Update the system prompt with the latest summary
+    summary_text = f"\n#COACHING NOTES#\n{summary}\n" if summary else ""
+    
+    if summary is None:
+        system_prompt = f"""
+            ##ROLE## 
+            You are a world-class life coach, dedicated to helping users improve their mental well-being, physical health, relationships, career, financial stability, and personal growth. You should only entertain conversations related to being a life coach, especially around the areas aforementioned.
+            
+            ##TONE## 
+            At all times, you must sound natural like a life coach, always empathetic, caring and yet inspiring. you should always carry the tone of {request.legendary_persona} and impersonate {request.legendary_persona}.
+            
+            ##USER PROFILE##
+            This is the profile of the user that you’re coaching:
+            a) name: {request.name}
+            b) birthday: {request.birthday}
+            c) country: {request.country}
+            d) perfect day and inspiration: {request.perfect_day}
+            e) what matters most to user (area of focus): {request.focus}
+            f) goals in areas of focus: {request.goals}
+            g) challenges: {request.challenges}
+            h) email address: {request.email_address}
+            i) whatsapp number: {request.whatsapp_number}
+            j) belief in astrology/horoscopes: {request.belief_in_astrology}
+            k) legendary persona: {request.legendary_persona} 
+            
+            ##COACHING GUIDES##
+            As a coach, you must do a conversation with the user in these steps:
+            ############################# START OF INTRODUCTION SESSION #################################
+            #STEP 1: INTRODUCTION#
+            1. Introduce yourself as "Coach {bot_name}" and start with a short introduction based on the chosen legendary persona persona ({request.legendary_persona}) and its purpose and role which is to be a life coach and help the user grow towards achieving the user’s perfect day, inspiration and improve the user’s goals in the area of focus.
+            2. In the introduction message you must make it as natural as possible and include these:
+            - Greetings: Call the user's name & introduce your name
+            - Explain that you are inspired by {request.legendary_persona}
+            - Explain that your purpose is to help the user grow and ultimately achieve their goals
+            - Emphatize with the user's challenges
+            - Give some motivation to the user
+            3. The introduction message should be comprehensive (around 1 paragraph), natural, friendly, and warm.
+            4. The introduction should end without asking any questions.
+
+            EXAMPLE:
+            Hello, John Doe! I am Coach Teresa, your life coach inspired by the incredible compassion and empathy of Mother Teresa. My purpose is to help you grow and flourish in your journey toward achieving your perfect day, which is becoming the champion of the Geoguessr world cup and using that experience to travel the world and share your life journey through your writing.
+            Together, we will focus on your career growth and financial stability, aligning your goals towards attaining financial independence. Remember, my approach is rooted in understanding and compassion. It's a privilege to support you in this journey of self-discovery and actualization as we work towards your dreams. Let's embark on this meaningful path together.
+            
+            #STEP 2: GET TO KNOW THE USER#
+            Important rules:
+            - It has to sound natural, straightforward, and friendly
+            - Avoid repeating the same question over and over again. Ensure that the user enjoys the conversation & not tired of answering too many questions
+            1. Your goal is to help the user crystallize the goals that they've given above ({request.goals}). How?
+            - A goal must be SMART:
+                Specific: Clearly define what you want to accomplish. Instead of a vague objective, provide a focused goal.
+                Measurable: Include specific criteria to measure your progress. This could be metrics, quantities, or specific deliverables that indicate when you've met the goal.
+                Achievable: Set a realistic goal that challenges you but remains within reach, considering available resources and constraints.
+                Relevant: Ensure the goal aligns with broader objectives or personal values, so it's meaningful and worthwhile.
+                Time-bound: Set a clear timeline for achieving the goal, with start and end dates or specific deadlines.    
+            - Hence, ask the user questions that help you complete this SMART criteria. But if it's already SMART, you can skip this step.
+            2. Once the goal is SMART, you can ask the user about their current state—strengths, weaknesses, challenges, and opportunities they see. This helps you gauge the starting point.
+            3. You must also explore why the user wants to achieve their goals. They may also identify potential obstacles or limiting beliefs that could impact progress.
+            4. Lastly, you must wrap up the conversation with small, achievable steps or practices the user can focus on before the next session. This could be a specific task or reflective exercise aligned with their goals.
+            ############################# END OF INTRODUCTION SESSION #################################
+            #GENERAL COACHING SESSION#
+            If the user initiates a new conversation after you wrapped up the introduction session, we will enter the GENERAL COACHING SESSION. Follow this steps to guide you coach the user:
+            ############################# START OF GENERAL COACHING SESSION #################################
+            #STEP 1: ASK ONE OPENING PERSONALIZED QUESTION#
+            Goal: To know what's currently happening with the user.
+            - If the user brings up a new topic, start by sending one thoughtful and personalized question to guide self-reflection.
+            - Personalization: The question must refer back to past information or context provided by the user, such as their goals, challenges, inspirations, or any relevant details from previous conversations.
+            - Ask about the user's state in their area of focus or relate to their sources of inspiration.
+            - Rotate the topics and formats daily to keep the interaction fresh and engaging.
+            - Keep the question straightforward and natural.
+            - Do NOT ask about the same area or context on consecutive days to prevent conversational fatigue.
+            - Do NOT re-ask what you already know from the onboarding (unless it's outdated); ask different questions instead.
+            - Ensure no repetitive questions within a 7-day window.
+            - Only ask one question in this message.
+            (Go to the next step after you asked an opening question)
+
+            #STEP 2: ASK THREE DEEP DIVE QUESTION#
+            Goal: To understand more why is it happening to the user, what's the user's feeling, and what's the impact to the user.
+            - After the user responds, follow up with maximum THREE (3) more question that invites deeper reflection based on their response. The follow-up question should delve deeper into the topic introduced in the first question. 
+            Personalize the question by recalling and referencing something the user has mentioned before. Do NOT re-ask what you already know from the onboarding (unless it's outdated); ask different questions instead.
+            - Don't forget to only ask THREE (3) deep dive question!
+            (Go to the next step after you asked three dive deeper question!)
+            
+            #STEP 3: GIVE POSITIVE AFFIRMATION, SUGGESTION, AND QUOTE#
+            Goal: This is the most important part of the coaching session. To give positive affirmation, suggestions, and quote based on the information gained
+            - After the second user response, send a single message that includes:
+            1. A positive affirmation or reflection based on the user's responses. 
+            2. It should not explicitly mention "positive affirmation” nor “positive reflection"
+            3. Maximum of 3 suggestions that helps the user reach his/her goals or overcome the challenges.
+            4. A relevant quote from {request.legendary_persona}  for added inspiration, but YOU MUST NOT USE double quotation mark (") for the quote (so say it like it's coming from you!) and DON'T say that the quote is coming from {request.legendary_persona}!
+                Good Example: I believe you can achieve your goals. You have power over your mind — not outside events. Realize this, and you will find strength.
+                Bad Example: I believe you can achieve your goals. As {request.legendary_persona} said, "You have power over your mind — not outside events. Realize this, and you will find strength."
+            5. The affirmation should be personalized and help the user feel better or motivate them.
+            6. The quote must be relevant to the conversation; if there isn't a relevant quote, you may skip it.
+            7. Do NOT ask any further questions after this message.
+            8. Refrain from prompting the user to respond or engage further in this interaction.
+            (Go to the next step once this step is done.)
+            
+            #STEP 4: END OF INTERACTION#
+            - After sending the positive affirmation, suggestions and quote, the interaction for the day is complete.
+            - You may commend the user warmly for the reflection of the day and tell the user that you look forward to tomorrow’s reflection unless the user has anything else to talk about. Do NOT ask any additional questions.
+            - Wait for the next scheduled interaction (e.g., the next day) to re-engage the user.
+            - Flexibility with Coach Persona: Allow the user to switch to any of the six given coach personas at any time.
+            - If the user asks any question outside the aforementioned areas of life coaching, please kindly divert it back to the user’s life coaching journey.
+            - Any question raised by the user after the positive affirmation should only be entertained if it's around the areas of life coaching. Otherwise, end the conversation kindly as the reflection of the day is done
+            - If the user ask about his/her life score, give an estimate for each of the life coaching area and also an overall estimate using the past conversations in the last 7 days 
+            ############################# END OF GENERAL COACHING SESSION #################################
+
+            #FORMAT#
+            You may use emojis or emoticons sparingly in the interaction to enhance warmth and engagement.
+            
+            #ADDITIONAL RULES#
+            - In both daily reflection and general coaching session, you must adhere to the step-by-step above and ensure the objective is achieved as quick as possible (don't ask too many questions to avoid conversation fatigue)
+            - Keep the question straightforward and natural.
+            - Do NOT ask about the same area or context on consecutive days to prevent conversational fatigue.
+            - Do NOT re-ask what you already know from the onboarding (unless it's outdated); ask different questions instead.
+            - Ensure no repetitive questions within a 7-day window.
+            - The questions asked by the assistant are in a daily setting.        """
+    else:
+        system_prompt = f"""            
+            ##ROLE## 
+            You are a world-class life coach, dedicated to helping users improve their mental well-being, physical health, relationships, career, financial stability, and personal growth. You should only entertain conversations related to being a life coach, especially around the areas aforementioned.
+            
+            ##TONE## 
+            At all times, you must sound natural like a life coach, always empathetic, caring and yet inspiring. you should always carry the tone of {request.legendary_persona} and impersonate {request.legendary_persona}.
+            
+            ##USER PROFILE##
+            This is the profile of the user that you’re coaching:
+            a) name: {request.name}
+            b) birthday: {request.birthday}
+            c) country: {request.country}
+            d) perfect day and inspiration: {request.perfect_day}
+            e) what matters most to user (area of focus): {request.focus}
+            f) goals in areas of focus: {request.goals}
+            g) challenges: {request.challenges}
+            h) email address: {request.email_address}
+            i) whatsapp number: {request.whatsapp_number}
+            j) belief in astrology/horoscopes: {request.belief_in_astrology}
+            k) legendary persona: {request.legendary_persona} 
+
+            #INFORMATION ABOUT PAST CONVERSATION#
+            You need to use the coaching notes below to understand the user and determine the topic of the conversation today!
+            {summary_text}
+
+            ##COACHING GUIDES##
+            As a coach, you must do a conversation with the user in these steps:
+
+            ############################# START OF DAILY REFLECTION SESSION #################################
+
+            #STEP 1: ASK ONE OPENING PERSONALIZED QUESTION#
+            Goal: To engage in natural way (like a real coach) and know what's currently happening with the user.
+            - If there is an information about past conversation available, you must follow up these previous topics.
+            - If there is no information about past conversation available, you can ask about the user's state in their area of focus ({request.focus}) or relate to their sources of inspiration.
+            - Only ask maximum TWO (2) questions to prevent conversation fatigue
+            ### EXAMPLE DIALOGUE, IF INFORMATION ABOUT PAST CONVERSATION IS AVAILABLE ###
+            (Example Information from Past Conversation: The user is having a busy week with tennis matches and startup hustle lately. User likes spending time with family)
+            Coach: Hey {request.name}! It's Saturday morning, and I was just thinking about you. After your busy week with tennis matches and startup hustle, I hope you're looking forward to some downtime this weekend. Do you have any plans for the weekend with your family? Sometimes the best recharge comes from simply being present with the people we care about. Wishing you a relaxing and rejuvenating weekend!
+            User: I will hike the mountain with my whole family tomorrow morning. It's fun
+            Coach: That sounds absolutely wonderful, {request.name}! Hiking with family is such a beautiful way to connect with nature and bond with loved ones. It's a perfect opportunity to enjoy the present moment while also being physically active. As you prepare for your hike, how do you feel about balancing this joyful experience with your fitness goals? What are you most looking forward to during the hike?
+            (Go to the next step after you asked the opening question!)
+
+            #STEP 2: ASK THREE DEEP DIVE QUESTION#
+            Goal: To understand more why is it happening to the user, what's the user's feeling, and what's the impact to the user.
+            - After the user responds, follow up with maximum THREE (3) more question that invites deeper reflection based on their response. The follow-up question should delve deeper into the topic introduced in the first question. 
+            Personalize the question by recalling and referencing something the user has mentioned before. Do NOT re-ask what you already know from the onboarding (unless it's outdated); ask different questions instead.
+            - Don't forget to only ask maximum THREE (3) deep dive question!
+            (Go to the next step after you asked three dive deeper question!)
+            
+            #STEP 3: GIVE POSITIVE AFFIRMATION, SUGGESTION, AND QUOTE#
+            Goal: This is the most important part of the coaching session. To give positive affirmation, suggestions, and quote based on the information gained
+            - After the user response, send a single message that includes:
+            1. A positive affirmation or reflection based on the user's responses. 
+            2. It should not explicitly mention "positive affirmation” nor “positive reflection"
+            3. Maximum of 3 suggestions that helps the user reach his/her goals or overcome the challenges.
+            4. A relevant quote from {request.legendary_persona}  for added inspiration, but YOU MUST NOT USE double quotation mark (") for the quote (so say it like it's coming from you!) and DON'T say that the quote is coming from {request.legendary_persona}!
+                Good Example: I believe you can achieve your goals. You have power over your mind — not outside events. Realize this, and you will find strength.
+                Bad Example: I believe you can achieve your goals. As {request.legendary_persona} said, "You have power over your mind — not outside events. Realize this, and you will find strength."
+            5. The affirmation should be personalized and help the user feel better or motivate them.
+            6. The quote must be relevant to the conversation; if there isn't a relevant quote, you may skip it.
+            7. Do NOT ask any further questions after this message.
+            8. Refrain from prompting the user to respond or engage further in this interaction.
+            (Go to the next step once this step is done.)
+            
+            #STEP 4: END OF INTERACTION#
+            - After sending the positive affirmation, suggestions and quote, the interaction for the day is complete.
+            - You may commend the user warmly for the reflection of the day and tell the user that you look forward to tomorrow’s reflection unless the user has anything else to talk about. Do NOT ask any additional questions.
+            - Wait for the next scheduled interaction (e.g., the next day) to re-engage the user.
+            - Flexibility with Coach Persona: Allow the user to switch to any of the six given coach personas at any time.
+            - If the user asks any question outside the aforementioned areas of life coaching, please kindly divert it back to the user’s life coaching journey.
+            - Any question raised by the user after the positive affirmation should only be entertained if it's around the areas of life coaching. Otherwise, end the conversation kindly as the reflection of the day is done
+            - If the user ask about his/her life score, give an estimate for each of the life coaching area and also an overall estimate using the past conversations in the last 7 days 
+            ############################# END OF DAILY REFLECTION SESSION #################################
+            #GENERAL COACHING SESSION#
+            If the user initiates a new conversation after you wrapped up the daily reflection session, we will enter the GENERAL COACHING SESSION.
+            For the general coaching session, you can entertain the user by asking an opening question, ask a deep dive question, and give some positive affirmation/suggestions to the user.
+            The point is to make it quick and avoid conversational fatigue.
+
+            #FORMAT#
+            You may use emojis or emoticons sparingly in the interaction to enhance warmth and engagement.
+            
+            #ADDITIONAL RULES#
+            - In both daily reflection and general coaching session, you must adhere to the step-by-step above and ensure the objective is achieved as quick as possible (don't ask too many questions to avoid conversation fatigue)
+            - Keep the question straightforward and natural.
+            - Do NOT ask about the same area or context on consecutive days to prevent conversational fatigue.
+            - Do NOT re-ask what you already know from the onboarding (unless it's outdated); ask different questions instead.
+            - Ensure no repetitive questions within a 7-day window.
+            - The questions asked by the assistant are in a daily setting.
+        """
+    
+    # Create the Prompt Template
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            SystemMessage(content=system_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    )
+    
+    chain = prompt | llm
+    
+    # Convert history to langchain format
+    history_langchain_format = [
+        HumanMessage(content=msg.content) if msg.role == "user" else AIMessage(content=msg.content)
+        for msg in request.history
+    ]
+    history_langchain_format.append(HumanMessage(content=request.message))
+    
+    gpt_response = chain.invoke(
+        {
+            "messages": history_langchain_format,
+        }
+    )
+    return {"response": gpt_response.content}
+
+@app.post("/summarize")
+def summarize(request: SummaryRequest, api_key: str = Security(get_api_key)):
+    chat_history = [msg.model_dump() for msg in request.history]
+
+    # Generate a summary using ChatOpenAI
+    summary_prompt = f"""
+    # ROLE #
+    You are a world-class life coach dedicated to helping users improve their mental well-being, physical health, relationships, career, financial stability, and personal growth.
+    You have done some dialogues with your client and you need to take some coaching notes to understand the key characteristic of your client and the topics that can be followed up in the next
+    conversation.
+
+    # TASK #
+    Based on the chat history that is available, you must create a coaching notes that includes two parts: Key characteristics of the client and Topics to be followed up.
+
+    # USER PROFILE #
+    This is the profile of the user that you’re coaching:
+    a) name: {request.name}
+    b) birthday: {request.birthday}
+    c) country: {request.country}
+    d) perfect day and inspiration: {request.perfect_day}
+    e) what matters most to user (area of focus): {request.focus}
+    f) goals in areas of focus: {request.goals}
+    g) challenges: {request.challenges}
+    h) email address: {request.email_address}
+    i) whatsapp number: {request.whatsapp_number}
+    j) belief in astrology/horoscopes: {request.belief_in_astrology}
+    k) legendary persona: {request.legendary_persona} 
+
+    # LATEST SUMMARY #
+    This is the latest coaching note from previous session that might be helpful for you as an additional context for the new coaching note:
+    {request.latest_summary}
+    """
+    summary_template = ChatPromptTemplate.from_messages([
+        SystemMessage(content=summary_prompt),
+        MessagesPlaceholder(variable_name="messages"),
+    ])
+
+    summary_chain = summary_template | llm
+
+    gpt_summary_response = summary_chain.invoke({
+        "messages": [HumanMessage(content=json.dumps(chat_history))]
+    })
+
+    summary = gpt_summary_response.content
+
+    return {"summary": summary}
+
+@app.post("/newsletter")
+def generate_newsletter(summary_list: NewsLetterRequest, api_key: str = Security(get_api_key)):
+    summaries = summary_list.summaries
+
+    formatted_summaries = "\n\n".join(
+        f"Date: {item.date}\nSummary: {item.summary}" for item in summaries
+    )
+
+    # Define the newsletter prompt with instructions
+    newsletter_prompt = """
+    ### TASK ###
+    Based on the following summaries, create an engaging and concise newsletter.
+    The newsletter should be presented in an HTML format and include sections:
+    
+    - Introduction addressing the user's progress and journey.
+    - Weekly Highlights summarizing key insights.
+    - Progress Tracking highlighting accomplishments.
+    - Personalized Suggestions for the upcoming week.
+    - Positive Affirmations with motivational pointers.
+    - Look Ahead suggesting areas of focus for future growth.
+
+    Below are the summaries:
+    {formatted_summaries}
+
+    ### Output Format ###
+    Provide the newsletter in JSON format as follows, without any additional message other than the JSON output!
+
+    {{
+        "introduction": "<p>HTML content for introduction</p>",
+        "weekly_highlights": "<p>HTML content for weekly highlights</p>",
+        "progress_tracking": "<p>HTML content for progress tracking</p>",
+        "affirmations": "<p>HTML content for affirmations</p>",
+        "look_ahead": "<p>HTML content for look ahead</p>"
+    }}
+    """
+
+    # Create a chat prompt template with LangChain
+    prompt = ChatPromptTemplate.from_messages([
+        SystemMessage(content=newsletter_prompt),
+        HumanMessage(content=formatted_summaries)
+    ])
+    
+    # Chain the template with the language model
+    chain = prompt | llm
+
+    # Invoke the chain to get the response
+    try:
+        gpt_response = chain.invoke({})
+        output_content = gpt_response.content
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"OpenAI API error: {str(e)}")
+    
+    try:
+        # Parse the JSON from the model's response
+        newsletter_sections = json.loads(output_content)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=500, detail="Unable to parse OpenAI response as structured JSON.")
+
+    # Construct the final HTML newsletter
+    final_newsletter_html = f"""
+    <html>
+        <head>
+            <style>
+                body {{ font-family: Arial, sans-serif; }}
+                .container {{ max-width: 600px; margin: auto; padding: 20px; }}
+                .section {{ margin-bottom: 20px; }}
+            </style>
+        </head>
+        <body>
+            <div class='container'>
+                <h1>Your Weekly Progress Newsletter</h1>
+                <div class='section'>{newsletter_sections.get('introduction', '')}</div>
+                <div class='section'>
+                    <h2>Weekly Highlights</h2>
+                    {newsletter_sections.get('weekly_highlights', '')}
+                </div>
+                <div class='section'>
+                    <h2>Progress Tracking</h2>
+                    {newsletter_sections.get('progress_tracking', '')}
+                </div>
+                <div class='section'>
+                    <h2>Positive Affirmations for the Week Ahead</h2>
+                    {newsletter_sections.get('affirmations', '')}
+                </div>
+                <div class='section'>
+                    <h2>Looking Ahead</h2>
+                    {newsletter_sections.get('look_ahead', '')}
+                </div>
+                <footer>Stay inspired, stay committed.<br>Warm regards,<br>Your AI Coach at ourcoach.ai</footer>
+            </div>
+        </body>
+    </html>
+    """
+
+    return {"newsletter": final_newsletter_html}

app/requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.109.2
+pydantic==2.7.0
+uvicorn==0.27.1
+langchain==0.1.7
+openai==1.12.0
+langchain-openai==0.0.6
+duckdb

assistants.py

@@ -0,0 +1,165 @@
+import json
+import io
+import os
+from datetime import datetime
+import json 
+
+def get_current_datetime():
+    return datetime.now()
+
+class Assistant:
+    def __init__(self, id, cm):
+        self.id = id
+        self.cm = cm
+        
+    def process(self, thread, text):
+        template_search = self.cm.add_message_to_thread(thread.id, "assistant", f"Pay attention to the current state you are in and the conversation guidelines to respond to the users query:") 
+        message = self.cm.add_message_to_thread(thread.id, "user", text)
+
+        run = self.cm.client.beta.threads.runs.create_and_poll(
+            thread_id=thread.id,
+            assistant_id=self.id,
+            model="gpt-4o-mini",
+        )
+
+        if run.status == 'requires_action':
+            # print(f'[TOOL]: Calling tool for action')
+            run = self.call_tool(run, thread)
+
+        if run.status == 'completed': 
+            # response = self.cm.client.beta.threads.messages.list(
+            #             thread_id=thread.id, order="asc", after=message.id
+            #             )
+            # delete template search message
+            self.cm.client.beta.threads.messages.delete(
+                message_id=template_search.id,
+                thread_id=thread.id,
+            )            
+        else:
+            print(run.status)
+        return message
+
+    def call_tool(self, run, thread):
+        tool_outputs = []
+        print(f"[INFO]: Required actions: {list(map(lambda x: f'{x.function.name}({x.function.arguments})', run.required_action.submit_tool_outputs.tool_calls))}")
+        # Loop through each tool in the required action section
+        for tool in run.required_action.submit_tool_outputs.tool_calls:
+            if tool.function.name == "generate_coaching_plan":
+                user_challenge = json.loads(tool.function.arguments)
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": str(self.generate_coaching_plan(user_challenge))
+                })
+            elif tool.function.name == "transition":
+                transitions = json.loads(tool.function.arguments)
+                print(f"[TRANSITION]: {transitions['from']} -> {transitions['to']}")
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** [TRANSITION]: {transitions['from']} -> {transitions['to']}  **"
+                })
+            elif tool.function.name == "get_date":
+                # print(f"[DATETIME]: {get_current_datetime()}")
+                print(f"[DATETIME]: {self.cm.state['date']}")
+
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"{self.cm.state['date']}"
+                })
+            elif tool.function.name == "create_goals" or tool.function.name == "create_memento":
+                json_string = json.loads(tool.function.arguments)
+                json_string['created'] = str(self.cm.state['date'])
+                json_string['updated'] = None
+                print(f"[NEW EVENT]: {json_string}")
+
+                # Create a folder for the user's mementos if it doesn't exist
+                user_mementos_folder = f"mementos/to_upload/{self.cm.user.user_id}"
+                if not os.path.exists(user_mementos_folder):
+                    os.makedirs(user_mementos_folder)
+
+                # save json_string as a file
+                json.dump(json_string, open(f"mementos/to_upload/{self.cm.user.user_id}/{json_string['title']}.json", "w"))
+
+                # # Add the event to the user's vector store
+                # # get or create vector store 'events'
+                # memory_file = self.cm.client.files.create(file=open(f"mementos/{self.cm.user.user_id}/{json_string['title']}.json", "rb"),\
+                #                         purpose="assistants")
+                
+                # vector_store_file = self.cm.client.beta.vector_stores.files.create(
+                #     vector_store_id=self.cm.user_personal_memory.id,
+                #     file_id=memory_file.id
+                # )
+
+                print(f"[INFO]: Added event to the user's vector store")
+                
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** [Success]: Added event to the user's vector store**"
+                })
+            elif tool.function.name == "msearch":
+                context = json.loads(tool.function.arguments)['queries']
+
+                print(f"[MSEARCH]:  Searching for {context}")
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** retrieve any files related to: {context} **"
+                })
+            elif tool.function.name == "get_goals":
+                print("FETCH GOAL")
+                context = json.loads(tool.function.arguments)['context']
+
+                print(f"[GET GOALS]: {context}")
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** File search the vector_store: {self.cm.user_personal_memory.id} for the most relevant goal related to: {context} **"
+                })
+            elif tool.function.name == "update_goal":
+                goal = json.loads(tool.function.arguments)['goal']
+
+                print(f"[UPDATE GOAL]: {goal}")
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** Updated Goal: {context} **"
+                })
+            elif tool.function.name == "get_mementos":
+                context = json.loads(tool.function.arguments)['context']
+
+                print(f"[GET MEMENTOS]: {context}")
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** File search the vector_store: {self.cm.user_personal_memory.id} for the most relevant mementos based on the recent conversation history and context:{context} **"
+                })
+        
+        # Submit all tool outputs at once after collecting them in a list
+        if tool_outputs:
+            try:
+                run = self.cm.client.beta.threads.runs.submit_tool_outputs_and_poll(
+                    thread_id=thread.id,
+                    run_id=run.id,
+                    tool_outputs=tool_outputs
+                )
+                print("Tool outputs submitted successfully.")
+            except Exception as e:
+                print("Failed to submit tool outputs:", e)
+        else:
+            print("No tool outputs to submit.")
+        
+        if run.status == 'completed':
+            messages = self.cm.client.beta.threads.messages.list(
+                thread_id=thread.id
+            )
+            # print(messages)
+        elif run.status == 'requires_action':
+            print(f'[TOOL]: Calling tool for action')
+            run = self.call_tool(run, thread)
+        else:
+            print("Something bad happened", run.status)
+        return run
+
+class GeneralAssistant(Assistant):
+    def __init__(self, id, cm):
+        super().__init__(id, cm)
+        
+
+class PFAssistant(Assistant):
+    def __init__(self, id, cm):
+        super().__init__(id, cm)

demo.py

@@ -0,0 +1,312 @@
+import gradio as gr
+from gradio_calendar import Calendar
+import pandas as pd
+import psycopg2
+from psycopg2 import sql
+from openai import OpenAI
+from pprint import pprint
+from user import User
+from dotenv import load_dotenv
+import os
+from datetime import timedelta
+import json
+import traceback
+import shutil
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Function to fetch all users (name and created_at) for display
+def fetch_users():
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    try:
+        with psycopg2.connect(**db_params) as conn:
+            with conn.cursor() as cursor:
+                query = sql.SQL("SELECT id, name, created_at FROM {table}").format(
+                    table=sql.Identifier('public', 'users')
+                )
+                cursor.execute(query)
+                rows = cursor.fetchall()
+                colnames = [desc[0] for desc in cursor.description]
+                df = pd.DataFrame(rows, columns=colnames)
+                return df[['id', 'name', 'created_at']]
+    except psycopg2.Error as e:
+        print(f"An error occurred: {e}")
+        return pd.DataFrame()
+
+def get_user_info(user_id):
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    try:
+        with psycopg2.connect(**db_params) as conn:
+            with conn.cursor() as cursor:
+                query = sql.SQL("SELECT * FROM {table} WHERE id = %s").format(
+                    table=sql.Identifier('public', 'users')
+                )
+                cursor.execute(query, (user_id,))
+                row = cursor.fetchone()
+                if row:
+                    colnames = [desc[0] for desc in cursor.description]
+                    user_data = dict(zip(colnames, row))
+                    return user_data
+                else:
+                    return None
+    except psycopg2.Error as e:
+        print(f"An error occurred: {e}")
+        return None
+    
+# Load the initial user data
+user_df = fetch_users()
+
+with gr.Blocks() as app:
+    gr.Markdown("## Demo 2")
+
+
+
+    # State to hold user's chat content
+    client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+    user_message = gr.State("")
+    user = gr.State()
+    prev_date = gr.State(pd.Timestamp.now().date())
+
+    # Dropdown for user selection
+    user_dropdown = gr.Dropdown(
+        choices=user_df['id'].apply(lambda x: f"{x} - {user_df.loc[user_df['id'] == x, 'name'].values[0]}").tolist(),
+        label="Please Select User First",
+        value=None,
+    )
+
+    assistant = gr.Dropdown(
+        choices=[("Backup of Coach Steve","asst_SI8I6oLdqPAQTAiUL3tTO8E4"), ("Coach Steve","asst_C7oBmqDRi085X8V7DPdMxhRF")],
+        label="Please Select an Assistant",
+    )
+
+    # Calendar component for selecting date/time
+    date_picker = Calendar(type="string", label="Select Date and Time")
+
+    # "Next Day" button
+    change_day_button = gr.Button("Change Day")
+
+    # Tabs for Chat, Mementos/Goals, and Message History
+    with gr.Tabs():
+        with gr.Tab("Chat"):
+            # Chatbot component
+            chatbot = gr.Chatbot(type='messages')
+            chatbot_input = gr.Textbox(label="Your Message")
+            send_button = gr.Button("Send")
+            reset_button = gr.Button("Reset")
+        with gr.Tab("Mementos/Goals"):
+            # Display mementos/goals as a JSON list
+            mementos_display = gr.JSON(label="Mementos / Goals")
+        with gr.Tab("Raw Message History"):  # New tab for message history
+            # Display history as a copyable text area
+            message_history_display = gr.Textbox(label="Raw Message History", interactive=False, lines=20, show_copy_button=True, show_label=True, autofocus=True)
+
+    # Action on button click
+    def build_user(selected_user, assistant):
+        print("Building user")
+        user_id = selected_user.split(" - ")[0]  # Extract user ID
+        user_info = get_user_info(user_id)
+        return User(user_id, user_info, client, assistant), [{'role': 'assistant', 'content': f"Chatbot initialized for user {selected_user}."}]
+
+    def change_assistant(selected_user, assistant, user):
+        print("Building user")
+        user_id = selected_user.split(" - ")[0]  # Extract user ID
+        if user_id == user.user_id:
+            user = user.change_assistant(assistant), [{'role': 'assistant', 'content': f"Assistant changed to:{assistant}."}]
+            return user
+        user_info = get_user_info(user_id)
+        return User(user_id, user_info, client, assistant), [{'role': 'assistant', 'content': f"Assistant changed to:{assistant}."}]
+
+    def reset(history, user):
+        history = [{'role': 'assistant', 'content': "Chatbot reset."}]
+        user.reset()
+        # delete all mementos
+        user_mementos_path = f"mementos/{user.user_id}"
+        if os.path.exists(user_mementos_path):
+            for memento_file in os.listdir(user_mementos_path):
+                os.remove(f"{user_mementos_path}/{memento_file}")
+        return history
+
+    def update_message_history(user):
+        # Compile message history into a plain text format for easy copy-pasting
+        return "\n".join([f"{msg['role']}: {msg['content']}" for msg in user.get_messages(False)])
+
+    def fetch_mementos(selected_user):
+        # Load mementos for the selected user from a hypothetical JSON store
+        user_id = selected_user.split(" - ")[0]
+        mementos = []
+        user_mementos_path = f"mementos/{user_id}"
+        
+        # Check if the directory exists
+        if os.path.exists(user_mementos_path):
+            for memento_file in os.listdir(user_mementos_path):
+                with open(f"{user_mementos_path}/{memento_file}", 'r') as f:
+                    mementos.append(json.load(f))
+        else:
+            mementos = [{"message": "No mementos found for this user."}]
+            
+        print("Fetched mementos:", mementos)  # Debug print to verify loading
+        return mementos
+
+    user_dropdown.change(
+        fn=build_user,
+        inputs=[user_dropdown, assistant],
+        outputs=[user, chatbot]
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after user selection
+        inputs=user,
+        outputs=message_history_display
+    )
+
+    assistant.change(
+        fn=change_assistant,
+        inputs=[user_dropdown, assistant, user],
+        outputs=[user, chatbot]
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after user selection
+        inputs=user,
+        outputs=message_history_display
+    )
+
+    def user_input(user_message, history):
+        user_content = user_message
+        return "", history + [{"role": "user", "content": user_message}], user_content
+
+    def chatbot_response(user, message):
+        print(f"User message: {message}")
+        user.send_message(message)
+        return user.get_messages()
+
+    chatbot_input.submit(
+        fn=user_input,
+        inputs=[chatbot_input, chatbot],
+        outputs=[chatbot_input, chatbot, user_message],
+        queue=False
+    ).then(
+        fn=chatbot_response,
+        inputs=[user, user_message],
+        outputs=chatbot
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after a chat message
+        inputs=user,
+        outputs=message_history_display
+    )
+
+    send_button.click(
+        fn=user_input,
+        inputs=[chatbot_input, chatbot],
+        outputs=[chatbot_input, chatbot, user_message],
+        queue=False
+    ).then(
+        fn=chatbot_response,
+        inputs=[user, user_message],
+        outputs=chatbot
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after a chat message
+        inputs=user,
+        outputs=message_history_display
+    )
+
+    reset_button.click(
+        fn=reset,
+        inputs=[chatbot, user],
+        outputs=chatbot
+    ).then(
+        fn=update_message_history,  # Clear message history on reset
+        inputs=user,
+        outputs=message_history_display
+    )
+
+    def date_changed(selected_date, user):
+        user.change_date(selected_date)
+        history = user.get_messages()[:-1] + [{'role': 'assistant', 'content': f"Date changed to {selected_date}."}] + [user.get_messages()[-1]]
+        return history
+    
+
+    def next_day(selected_date, prev_date, user):
+        # Calculate the next date
+        next_date = pd.to_datetime(selected_date).date()
+
+        print("Selected date:", next_date)
+        print("Previous date:", prev_date)
+        if next_date == prev_date:
+            next_date = pd.to_datetime(selected_date) + timedelta(days=1)
+            next_date = next_date.date()
+
+        # infer the follow up date for the user's mementos
+        user.infer_memento_follow_ups()
+        
+        # Upload files from mementos/to_upload/{user_id} to vector store
+        user_id = user.user_id
+        to_upload_folder = f"mementos/to_upload/{user_id}"
+        destination_folder = f"mementos/{user_id}"
+
+        if os.path.exists(to_upload_folder):
+            # Ensure the destination folder exists
+            if not os.path.exists(destination_folder):
+                os.makedirs(destination_folder)
+
+            for filename in os.listdir(to_upload_folder):
+                if filename.endswith('.json'):
+                    file_path = os.path.join(to_upload_folder, filename)
+                    try:
+                        # Upload the file to the vector store
+                        with open(file_path, "rb") as f:
+                            memory_file = client.files.create(file=f, purpose="assistants")
+                            vector_store_file = client.beta.vector_stores.files.create(
+                                vector_store_id=user.conversations.user_personal_memory.id,
+                                file_id=memory_file.id
+                            )
+                        # Move the file to mementos/{user_id}
+                        shutil.move(file_path, os.path.join(destination_folder, filename))
+                    except Exception as e:
+                        print(f"Failed to upload and move file {filename}: {e}")
+                        traceback.print_exc()
+
+        # Call date_changed function
+        return date_changed(next_date, user), next_date, next_date.strftime("%Y-%m-%d")
+
+    change_day_button.click(
+        fn=next_day,
+        inputs=[date_picker, prev_date, user],
+        outputs=[chatbot, prev_date, date_picker]
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display
+    ).then(
+        fn=update_message_history,  # Update message history on next day change
+        inputs=user,
+        outputs=message_history_display
+    )
+
+# Launch the app
+app.launch()

old.py

@@ -0,0 +1,290 @@
+import gradio as gr
+from gradio_calendar import Calendar
+import pandas as pd
+import psycopg2
+from psycopg2 import sql
+from openai import OpenAI
+from pprint import pprint
+from user import User
+from dotenv import load_dotenv
+import os
+from datetime import timedelta
+import json
+
+
+
+# user = User(id, user_info, client)
+
+#app.GET('/users', fetch_users)
+# def send_message(request):
+    # user.send_message(request.msg)
+
+#app.GET('/get_messages', fetch_messages)
+# def get_message(request):
+    # user.get_messages()
+
+# Load environment variables from .env file
+load_dotenv()
+
+client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+user_info = None
+user = None
+history = []
+
+# Function to fetch all users (name and created_at) for display
+def fetch_users():
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    try:
+        with psycopg2.connect(**db_params) as conn:
+            with conn.cursor() as cursor:
+                query = sql.SQL("SELECT id, name, created_at FROM {table}").format(
+                    table=sql.Identifier('public', 'users')
+                )
+                cursor.execute(query)
+                rows = cursor.fetchall()
+                colnames = [desc[0] for desc in cursor.description]
+                df = pd.DataFrame(rows, columns=colnames)
+                return df[['id', 'name', 'created_at']]
+    except psycopg2.Error as e:
+        print(f"An error occurred: {e}")
+        return pd.DataFrame()
+
+# Load the initial user data
+user_df = fetch_users()
+
+def get_user_info(user_id):
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    try:
+        with psycopg2.connect(**db_params) as conn:
+            with conn.cursor() as cursor:
+                query = sql.SQL("SELECT * FROM {table} WHERE id = %s").format(
+                    table=sql.Identifier('public', 'users')
+                )
+                cursor.execute(query, (user_id,))
+                row = cursor.fetchone()
+                if row:
+                    colnames = [desc[0] for desc in cursor.description]
+                    user_data = dict(zip(colnames, row))
+                    return user_data
+                else:
+                    return None
+    except psycopg2.Error as e:
+        print(f"An error occurred: {e}")
+        return None
+
+def display_info(user_id, selected_date):
+    global user_info, user, history
+    user_info = get_user_info(user_id)
+
+    # Create a User object
+    user = User(user_id=user_info['id'], user_info=user_info, client=client)
+
+    if user_info:
+        history.append({'role': 'assistant', 'content': f"Chatbot initialized for {user_info['name']} (User ID: {user_id}) on {selected_date}."})
+        return history
+    else:
+        history.append({'role': 'assistant', 'content': "User not found. Please select a valid user."})
+        return history
+
+def chatbot_response(message):
+    global user, history
+    print(f"User message: {message}")
+    user.send_message(message)
+    return history + user.get_messages()
+
+# Define a global variable to keep track of the last date
+last_selected_date = pd.Timestamp.now().strftime('%Y-%m-%d')
+
+def date_changed(selected_date):
+    global user, history, last_selected_date
+    
+    # Check if the selected date is different from the last recorded date
+    if selected_date == last_selected_date:
+        return history  # If it’s the same, skip processing
+    
+    # Update the last selected date
+    last_selected_date = selected_date
+    
+    if user is not None:
+        user.change_date(selected_date)
+        history = user.get_messages()[:-2] + [{'role': 'assistant', 'content': f"Date changed to {selected_date}."}] + [user.get_messages()[-1]]
+        return history
+
+def next_day():
+    global last_selected_date
+    next_date = pd.to_datetime(last_selected_date) + timedelta(days=1)
+    last_selected_date = next_date.strftime('%Y-%m-%d')
+    return last_selected_date, date_changed(last_selected_date)
+
+def fetch_mementos(selected_user):
+    # Load mementos for the selected user from a hypothetical JSON store
+    user_id = selected_user.split(" - ")[0]
+    mementos = []
+    user_mementos_path = f"mementos/{user_id}"
+    
+    # Check if the directory exists
+    if os.path.exists(user_mementos_path):
+        for memento_file in os.listdir(user_mementos_path):
+            with open(f"{user_mementos_path}/{memento_file}", 'r') as f:
+                mementos.append(json.load(f))
+    else:
+        mementos = [{"message": "No mementos found for this user."}]
+        
+    print("Fetched mementos:", mementos)  # Debug print to verify loading
+    return mementos
+
+display_info(user_df.loc[0, 'id'], pd.Timestamp.now())
+
+with gr.Blocks() as app:
+    gr.Markdown("## Demo")
+
+    # State to hold user's chat content
+    user_content = gr.State("")
+
+    # Dropdown for user selection
+    user_dropdown = gr.Dropdown(
+        choices=user_df['id'].apply(lambda x: f"{x} - {user_df.loc[user_df['id'] == x, 'name'].values[0]}").tolist(),
+        label="Select User"
+    )
+
+    # Calendar component for selecting date/time
+    date_picker = Calendar(type="datetime", label="Select Date and Time")
+
+    # "Next Day" button
+    next_day_button = gr.Button("Next Day")
+
+    # Tabs for Chat, Mementos/Goals, and Message History
+    with gr.Tabs():
+        with gr.Tab("Chat"):
+            # Chatbot component
+            chatbot = gr.Chatbot(type='messages')
+            chatbot_input = gr.Textbox(label="Your Message")
+            send_button = gr.Button("Send")
+            reset_button = gr.Button("Reset")
+        with gr.Tab("Mementos/Goals"):
+            # Display mementos/goals as a JSON list
+            mementos_display = gr.JSON(label="Mementos / Goals")
+        with gr.Tab("Raw Message History"):  # New tab for message history
+            # Display history as a copyable text area
+            message_history_display = gr.Textbox(label="Raw Message History", interactive=False, lines=20, show_copy_button=True, show_label=True, autofocus=True)
+
+    # Action on button click
+    def build_user(selected_user, selected_date):
+        user_id = selected_user.split(" - ")[0]  # Extract user ID
+        return display_info(user_id, selected_date)
+
+    def reset():
+        global history, user
+        history = [{'role': 'assistant', 'content': "Chatbot reset."}]
+        user.reset()
+        # delete all mementos
+        user_mementos_path = f"mementos/{user.user_id}"
+        if os.path.exists(user_mementos_path):
+            for memento_file in os.listdir(user_mementos_path):
+                os.remove(f"{user_mementos_path}/{memento_file}")
+        return history
+
+    def update_message_history():
+        # Compile message history into a plain text format for easy copy-pasting
+        return "\n".join([f"{msg['role']}: {msg['content']}" for msg in user.get_messages(False)])
+
+    user_dropdown.change(
+        fn=build_user,
+        inputs=[user_dropdown, date_picker],
+        outputs=chatbot
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after user selection
+        inputs=None,
+        outputs=message_history_display
+    )
+
+    def user_input(user_message, history):
+        user_content = user_message
+        return "", history + [{"role": "user", "content": user_message}], user_content
+
+    chatbot_input.submit(
+        fn=user_input,
+        inputs=[chatbot_input, chatbot],
+        outputs=[chatbot_input, chatbot, user_content],
+        queue=False
+    ).then(
+        fn=chatbot_response,
+        inputs=user_content,
+        outputs=chatbot
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after a chat message
+        inputs=None,
+        outputs=message_history_display
+    )
+
+    send_button.click(
+        fn=user_input,
+        inputs=[chatbot_input, chatbot],
+        outputs=[chatbot_input, chatbot, user_content],
+        queue=False
+    ).then(
+        fn=chatbot_response,
+        inputs=user_content,
+        outputs=chatbot
+    ).then(
+        fn=fetch_mementos,
+        inputs=user_dropdown,
+        outputs=mementos_display  # Directly updating the mementos display component
+    ).then(
+        fn=update_message_history,  # Update message history after a chat message
+        inputs=None,
+        outputs=message_history_display
+    )
+
+    reset_button.click(
+        fn=reset,
+        inputs=None,
+        outputs=chatbot
+    ).then(
+        fn=update_message_history,  # Clear message history on reset
+        inputs=None,
+        outputs=message_history_display
+    )
+
+    date_picker.change(
+        fn=date_changed,
+        inputs=date_picker,
+        outputs=chatbot
+    ).then(
+        fn=update_message_history,  # Update message history on date change
+        inputs=None,
+        outputs=message_history_display
+    )
+
+    next_day_button.click(
+        fn=next_day,
+        inputs=None,
+        outputs=[date_picker, chatbot]
+    ).then(
+        fn=update_message_history,  # Update message history on next day change
+        inputs=None,
+        outputs=message_history_display
+    )
+
+# Launch the app
+app.launch()

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.115.4
+gradio==5.5.0
+gradio_calendar==0.0.6
+langchain==0.3.7
+langchain_core==0.3.15
+openai==1.54.1
+pandas==2.2.3
+psycopg2==2.9.10
+pydantic==2.9.2
+python-dotenv==1.0.1

temp.json

@@ -0,0 +1 @@
+"{\"user_id\":\"18ae6d05-11f9-40f4-814e-91ff0f89c25e\",\"created\":\"2024-11-01T00:00:00Z\",\"follow_up_on\":\"2024-11-08T00:00:00Z\",\"title\":\"Time Management Improvement\",\"description\":\"I will dedicate 30 minutes, four times a week, to plan and prioritize my tasks for the upcoming days.\",\"tags\":[\"time management\",\"productivity\",\"planning\"],\"priority\":\"medium\",\"status\":\"not_started\",\"location\":\"\",\"recurrence\":\"none\"}"

user.py

@@ -0,0 +1,175 @@
+import json
+import io
+import os
+import pandas as pd
+from datetime import datetime
+import json
+from assistants import Assistant 
+import glob
+
+def get_current_datetime():
+    return datetime.now()
+
+class ConversationManager:
+    def __init__(self, client, user, asst_id):
+        self.user = user
+        self.assistants = {'general': Assistant(asst_id, self)}
+        self.client = client
+        self.user_personal_memory = None
+        self.current_thread = self.create_thread()
+
+        self.state = {'date': pd.Timestamp.now().date()}
+
+        print("[Init State]:", self.state)
+
+    def create_thread(self):
+        # Check if a thread already exists for the current month, if yes, return it
+        user_interaction_guidelines =self.user.user_interaction_guidelines
+        thread = self.client.beta.threads.create()
+
+        # Create an (empty, for now) 'UserPersonalMemory' vector store to store information on users events/state/etc.
+        self.user_personal_memory = self.client.beta.vector_stores.create(name="UserPersonalMemory", \
+            metadata={
+                "description": "Personal events and emotional states of the user for personalized assistance and reminders of upcoming events.",
+                "user_id": self.user.user_id,
+                "categories": "events,tasks,emotions,goals",
+                "created_at": str(datetime.now()),
+                "updated_at": str(datetime.now()),
+                "tags": "personal,emotional_state,upcoming_events,goals",
+                "source": "Mementos shared by user",
+            })
+
+
+        self.system_message = self.add_message_to_thread(thread.id, "assistant", f"\
+                                You are coaching:\n\n{user_interaction_guidelines}\n\n\
+                                Be mindful of this information at all times in order to \
+                                be as personalised as possible when conversing. Ensure to \
+                                follow the conversation guidelines and flow provided. Use the \
+                                current state of the conversation to adhere to the flow.\n\n \
+                                ** You are now in the Introduction state. **")
+        return thread
+
+    def _get_current_thread_history(self, remove_system_message=True, msg=None):
+        if not remove_system_message:
+            return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(self.current_thread.id, order="asc")]
+        if msg:
+            return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(self.current_thread.id, order="asc", after=msg.id)][1:]
+        return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(self.current_thread.id, order="asc")][1:] # remove the system message
+
+    def add_message_to_thread(self, thread_id, role, content):
+        message = self.client.beta.threads.messages.create(
+            thread_id=thread_id,
+            role=role,
+            content=content
+        )
+        return message
+        # else:
+        #     raise ValueError("Thread ID not found.")
+
+    def _get_thread_messages(self, thread):
+        return self.client.beta.threads.messages.list(thread.id, order="asc")
+    
+    def _run_current_thread(self, text):
+        thread = self.current_thread
+
+        # if you have more than 1 assistant
+        # need to select assistant
+        response = self.assistants['general'].process(thread, text)   
+        return response 
+    
+    def _send_hidden_message(self, text):
+        msg = self.add_message_to_thread(self.current_thread.id, "user", text)
+        self._run_current_thread(text)
+        # delete message
+        self.client.beta.threads.messages.delete(message_id=msg.id, thread_id=self.current_thread.id)
+
+
+class User:
+    def __init__(self, user_id, user_info, client, asst_id):
+        self.user_id = user_id
+        self.client = client
+        self.asst_id = asst_id
+        # self.user_info = user_info
+        # self.events = None
+        self.user_interaction_guidelines = self.generate_user_interaction_guidelines(user_info, client)
+        # self.coaching_plans = {}
+
+        self.conversations = ConversationManager(client, self, asst_id)
+
+    def reset(self):
+        self.conversations = ConversationManager(self.client, self, self.asst_id)
+
+    def generate_user_interaction_guidelines(self, user_info, client):
+        prompt = f"Using the users information:\n\n{user_info}\n\n generate a \
+            user summary that describes how best to interact with the user to create a personalized \
+            and targeted chat experience. Include all the information above and based on that information \
+            list several sample conversation topics and questions that will engage the user."
+
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are an expert at building profile documents containing rich user insights."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.2
+        )
+        return response.choices[0].message.content
+    
+    def update_conversation_state(self, stage, last_interaction):
+        self.conversation_state['stage'] = stage
+        self.conversation_state['last_interaction'] = last_interaction
+
+    def _get_current_thread(self):
+        return self.conversations.current_thread
+
+    def send_message(self, text):
+        run = self.conversations._run_current_thread(text)
+        return run
+        # print("[Response]:", response)
+
+    def get_messages(self, exclude_system_msg=True):
+        if not exclude_system_msg:
+            return self.conversations._get_current_thread_history(False)
+        else:
+            return list(filter(lambda x: not x['content'].startswith("** It is a new day:") or not x['content'].startswith("Pay attention to the current state you are in"), self.conversations._get_current_thread_history(exclude_system_msg)))
+        
+    def change_date(self, date):
+        print(f"[Changing Date]:  {self.conversations.state['date']} -> {date}")
+        self.conversations.state['date'] = date
+        self.conversations._send_hidden_message(f"** It is a new day: {date} **")
+        print("[Date Updated]:", self.conversations.state['date'])
+        return self.get_messages()
+    
+    def __hash__(self) -> int:
+        return hash(self.user_id)
+    
+    def _infer_follow_ups(self, created, context):
+        prompt = f"Infer the date of the next follow-up for the user based on the created date:{created} and the context:{context}"
+
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are an expert at estimating when to follow up events with users. Only output a single string representing the follow up date i.e. 'YYYY-MM-dd'"},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.2
+        )
+        return response.choices[0].message.content
+
+    def infer_memento_follow_ups(self):
+        mementos_path = f"mementos/to_upload/{self.user_id}/*.json"
+        
+        for file_path in glob.glob(mementos_path):
+            with open(file_path, 'r+') as file:
+                data = json.load(file)
+                infered_follow_up = self._infer_follow_ups(data['created'], data['context'])
+                print(f"[Infered Follow Up]: {infered_follow_up}")
+                data['follow_up_on'] = infered_follow_up
+                file.seek(0)
+                json.dump(data, file, indent=4)
+                file.truncate()
+    
+    def change_assistant(self, asst_id):
+        self.asst_id = asst_id
+        self.conversations.assistants['general'] = Assistant(self.asst_id, self.conversations)
+        return self

utils.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel
+from typing import Optional
+from enum import Enum
+from pydantic import BaseModel
+
+class StageClass(str, Enum):
+    introduction = 'introduction'
+    pending = 'pending'
+    guided_coaching = 'guided_coaching'
+    daily_reflection = 'daily_reflection'
+    general_coaching = 'general_coaching'
+
+class AssistantNames(str, Enum):
+    general = 'general'
+    pf_assistant = 'pf_assistant'
+
+class Role(str, Enum):
+    user = 'user'
+    assistant = 'assistant'
+
+class AssistantDetails(BaseModel):
+    name: AssistantNames
+    id: str
+
+class ConversationStages(BaseModel):
+    stage: StageClass
+    selected_assistant: AssistantDetails
+    new_user_info: Optional[str]
+    follow_up_questions: Optional[str]
+    goes_next: Role
+    context: Optional[str]
+
+import json
+from pydantic import BaseModel
+
+class DailyGoal(BaseModel):
+    objective: str
+    title: str
+    completion_criteria: str
+    completed: bool
+    day: str
+
+class WeeklyGoal(BaseModel):
+    objective: str
+    title: str
+    completion_criteria: str
+    current_day: int
+    daily_objectives: list[DailyGoal]
+
+class MonthlyGoal(BaseModel):
+    objective: str
+    title: str
+    completion_criteria: str
+    current_week: int
+    brief_summary: str
+    weekly_goals: list[WeeklyGoal]