Implement GenAI functionality

a-kori · a-kori · commit cd5443ff1f26 · 2025-07-20T13:59:16.000+02:00
diff --git a/deployment/README.md b/deployment/README.md
@@ -4,6 +4,9 @@ The `deployment` directory contains necessary files for the deployment of Meet@M
 To deploy the system manually on your local machine, follow the guides below. Automated deployment workflows in GitHub Actions can be found under `../.github/workflows`.
 
 ## Docker Compose
+Prerequisites:
+- a `.env` file is located in `/docker` directory and contains the `OPENAI_API_KEY` secret for the GenAI service (in AWS deployment, a GitHub secret is used instead)
+
 Use the following commands to start / stop / inspect the project using Docker Compose:
 ```
 cd docker                       # Move to docker directory
@@ -26,6 +29,12 @@ kubectl create secret generic <match/user>-db-secret \
   --from-literal=MYSQL_ROOT_PASSWORD='<your-password>' \
   --namespace devoops
 ```
+- OpenAI API key is saved as secret in the `devoops` namespace:
+```
+kubectl create secret generic genai-secret \
+  --from-literal=OPENAI_API_KEY=sk-... \
+  --namespace devoops
+```
 
 Once the three requirements are fulfilled, you can run the application:
 ```
diff --git a/deployment/compose.aws.yml b/deployment/compose.aws.yml
@@ -98,6 +98,8 @@ services:
 
   meetatmensa-genai:
     image: ghcr.io/aet-devops25/team-devoops/genai:latest
+    environment:
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
     container_name: meetatmensa-genai
     labels:
       - traefik.enable=true
diff --git a/deployment/docker/compose.yml b/deployment/docker/compose.yml
@@ -41,6 +41,8 @@ services:
       - "80"
     networks:
       - backend
+    env_file:
+      - .env
 
   meetatmensa-client:
     build: 
diff --git a/deployment/k8s/charts/genai/templates/deployment.yaml b/deployment/k8s/charts/genai/templates/deployment.yaml
@@ -40,6 +40,12 @@ spec:
           {{- end }}
           image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
           imagePullPolicy: {{ .Values.image.pullPolicy }}
+          env:
+          - name: OPENAI_API_KEY
+            valueFrom:
+              secretKeyRef:
+                name: genai-secret
+                key: OPENAI_API_KEY
           ports:
             - name: http
               containerPort: {{ .Values.service.port }}
diff --git a/infrastructure/ansible/playbooks/deploy.yml b/infrastructure/ansible/playbooks/deploy.yml
@@ -105,4 +105,5 @@
         remove_orphans: yes
       environment:
         DOCKER_BUILDKIT: 1
-        EC2_PUBLIC_IP: "{{ ansible_host }}"
+        EC2_PUBLIC_IP: "{{ ansible_host }}"
+        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
diff --git a/server/chat/gradle/wrapper/gradle-wrapper.jar b/server/chat/gradle/wrapper/gradle-wrapper.jar
diff --git a/server/gateway/gradle/wrapper/gradle-wrapper.jar b/server/gateway/gradle/wrapper/gradle-wrapper.jar
diff --git a/server/gateway/src/main/resources/application.yml b/server/gateway/src/main/resources/application.yml
@@ -41,4 +41,4 @@ spring:
         - id: genai_route
           uri: http://meetatmensa-genai:80
           predicates:
-            - Path=/genai/**
+            - Path=/api/v2/genai/**
diff --git a/server/genai/.gitkeep b/server/genai/.gitkeep
diff --git a/server/genai/Dockerfile b/server/genai/Dockerfile
@@ -1,30 +1,35 @@
-# ------------ Build Stage ------------
-FROM python:3.10-slim AS build
-WORKDIR /app
-
-# Copy necessary files
-COPY pyproject.toml ./
-COPY src ./src
+# ---- Build stage (optional, for dependencies precompilation) ----
+FROM python:3.11-slim AS builder
 
-# install build tools
-RUN pip install build
+WORKDIR /app
+COPY requirements.txt .
 
-# build python wheel to be installed later
-RUN python3 -m build
+# System deps for common LangChain LLM backends (OpenAI, local models, etc.)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl && \
+    pip install --upgrade pip && \
+    pip install --prefix=/install -r requirements.txt && \
+    apt-get purge -y --auto-remove build-essential && \
+    rm -rf /root/.cache /var/lib/apt/lists/*
 
+# ---- Final stage ----
+FROM python:3.11-slim
 
-# ------------ Runtime Stage ------------
-FROM python:3.10-slim
+# Create non-root user
+RUN useradd -m appuser
 WORKDIR /app
 
-# copy wheel from build
-COPY --from=build /app/dist/*.whl .
+# Copy installed Python packages
+COPY --from=builder /install /usr/local
+COPY service/ ./service
+COPY requirements.txt .
+COPY test ./test
 
-# Install python wheel
-RUN pip install *.whl
+# Set env vars (can be overridden in Helm values)
+ENV PYTHONUNBUFFERED=1 \
+    PORT=80
 
-# Expose default HTTP port
+USER appuser
 EXPOSE 80
 
-# Run the conversation_starter.main:start_genai() via the project script
-CMD ["meetatmensa-start-genai"]
+CMD ["uvicorn", "service.main:app", "--host", "0.0.0.0", "--port", "80"]
diff --git a/server/genai/README.md b/server/genai/README.md
@@ -1,8 +1,13 @@
 # Meet@Mensa GenAI Microservice
 
-A Python application built using Hatchling enabling the Generative AI conversation starter using in the Meet@Mensa app.
+A FastAPI-based Python application built using LangChain enabling the Generative AI conversation starter in the Meet@Mensa app.
 
-Currently unimplemented, save for a placeholder webserver
+## Features
+
+* **LangChain integration** – swap cloud or local LLMs via dependency injection.
+* **FastAPI** endpoint conforming to the provided OpenAPI spec.
+* **Configurable** via environment variables.
+* **Test‑driven** – deterministic tests with a stubbed LLM.
 
 ## Local Deployment with Docker
 ```
@@ -13,7 +18,7 @@ docker build -t ghcr.io/aet-devops25/team-devoops/genai .
 docker push ghcr.io/aet-devops25/team-devoops/genai
 
 # Run the Docker container and map port 80 to the desired port
-docker run --name genai-service -p <desired_port>:80 ghcr.io/aet-devops25/team-devoops/genai
+docker run --name genai-service -e OPENAI_API_KEY=sk-YOURKEY -p <desired_port>:80 ghcr.io/aet-devops25/team-devoops/genai
 
 # List running containers (if needed)
 docker ps 
@@ -25,4 +30,4 @@ docker stop genai-service
 docker remove genai-service
 ```
 
-The application will be available at `http://localhost:<desired_port>`, followed by any path.
+The application will be available at `http://localhost:<desired_port>`.
diff --git a/server/genai/pyproject.toml b/server/genai/pyproject.toml
diff --git a/server/genai/requirements.txt b/server/genai/requirements.txt
@@ -0,0 +1,10 @@
+fastapi>=0.111
+uvicorn[standard]>=0.29
+langchain>=0.2
+langchain[community]>=0.0.280
+openai>=1.30
+pydantic>=2.0
+prometheus_client>=0.18.0
+
+# Testing
+pytest>=8.0
diff --git a/server/genai/service/config.py b/server/genai/service/config.py
@@ -0,0 +1,14 @@
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+class Settings(BaseSettings):
+    openai_api_key: str = Field(..., env="OPENAI_API_KEY")
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+settings = Settings()
+
+def get_settings():
+    return settings
diff --git a/server/genai/service/main.py b/server/genai/service/main.py
@@ -0,0 +1,112 @@
+from fastapi import FastAPI, Depends, HTTPException, status, Request, Body
+from fastapi.responses import PlainTextResponse
+from pydantic import ValidationError
+from prometheus_client import Counter, generate_latest, CONTENT_TYPE_LATEST
+from service.schemas import UserCollection, ConversationStarterCollection
+from service.config import Settings, get_settings
+from langchain_community.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage
+
+
+app = FastAPI(
+    title="GenAI Conversation Starter Service",
+    version="2.0",
+    description="Suggests conversation starters based on students' interests",
+)
+
+REQUEST_COUNT = Counter(
+    "genai_requests_total",
+    "Total HTTP requests to GenAI service",
+    ["endpoint"],
+)
+
+@app.get("/metrics")
+async def metrics():
+    REQUEST_COUNT.labels(endpoint="metrics").inc()
+    return PlainTextResponse(generate_latest(), media_type=CONTENT_TYPE_LATEST)
+
+
+@app.get(
+    "/api/v2/genai/conversation-starter",
+    response_model=ConversationStarterCollection,
+    tags=["GenAI"],
+    operation_id="get-api-v2-genai-conversation-starter",
+    summary="Request conversation starter",
+)
+async def get_conversation_starter(
+    request: Request,
+    users: UserCollection = Body(...),  # FastAPI supports body with GET but it's nonstandard
+    settings: Settings = Depends(get_settings),
+):
+    REQUEST_COUNT.labels(endpoint=str(request.url.path)).inc()
+
+    try:
+        if not users.users:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="User list is empty",
+            )
+        
+        # Build detailed prompt about users and their interests
+        # Build rich user descriptions for the LLM prompt
+        user_descriptions: list[str] = []
+        for user in users.users:
+            interests_str = (
+                ", ".join(interest.name for interest in user.interests)
+                if user.interests
+                else "no interests listed"
+            )
+            desc = (
+                f"{user.firstname} {user.lastname} "
+                f"({user.gender}, born {user.birthday.isoformat()}), "
+                f"email: {user.email}, "
+                f"degree program: {user.degree} (started {user.degreeStart}), "
+                f"bio: \"{user.bio}\", "
+                f"interests: {interests_str}."
+            )
+            user_descriptions.append(desc)
+
+        prompt = (
+            "You are an assistant generating friendly, inclusive ice‑breaker questions "
+            "for a group lunch among students. Here are the participants:\n\n"
+            + "\n".join(user_descriptions)
+            + "\n\nGenerate some short, open‑ended conversation‑starter questions "
+            "that reference their backgrounds and interests."
+        )
+        print(f"Generated prompt:\n{prompt}")  # Debugging output
+
+        # Create a messages list for LangChain ChatOpenAI
+        llm = ChatOpenAI(openai_api_key=settings.openai_api_key)
+        messages = [[HumanMessage(content=prompt)]]
+        response = await llm.agenerate(messages)
+
+        print("Response from LLM:")   # Debugging output
+        print(type(response))
+        print(response)
+
+        # Extract the AI message content from the nested structure
+        content = response.generations[0][0].message.content
+
+        # Clean and extract individual starters from the content
+        starters = [
+            line.lstrip("- •*0123456789. ").strip()
+            for line in content.split("\n")
+            if line.strip()
+        ]
+
+        # Convert to schema format
+        conversation_starters = [{"prompt": starter} for starter in starters]
+
+        # Return in FastAPI-compatible response model
+        return ConversationStarterCollection(conversationsStarters=conversation_starters)
+
+    except ValidationError as ve:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(ve))
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+
+@app.get("/")
+async def root():
+    REQUEST_COUNT.labels(endpoint="/").inc()
+    return {"message": "Hello World! Welcome to the GenAI Service!"}
diff --git a/server/genai/service/schemas.py b/server/genai/service/schemas.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import List
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+# ── Shared  ────────────────────────────────────────────────────────────────────
+class Interest(BaseModel):
+    name: str = Field(..., description="Name of the interest, e.g. 'machine‑learning'")
+
+
+# ── Core domain models  ───────────────────────────────────────────────────────
+class User(BaseModel):
+    # Primary key
+    userID: UUID = Field(..., description="Unique identifier of the user")
+
+    # Personal data
+    email: str
+    firstname: str
+    lastname: str
+    birthday: date
+    gender: str = Field("other", description="Gender of the user")
+
+    # Academic data
+    degree: str
+    degreeStart: int
+
+    # Profile
+    interests: List[Interest]
+    bio: str
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "userID": "123e4567-e89b-12d3-a456-426614174000",
+                "email": "max@example.com",
+                "firstname": "Max",
+                "lastname": "Mustermann",
+                "birthday": "1998-06-15",
+                "gender": "male",
+                "degree": "msc_informatics",
+                "degreeStart": 2024,
+                "interests": [{"name": "AI"}, {"name": "DevOps"}],
+                "bio": "Coffee‑powered coder who loves climbing.",
+            }
+        }
+
+
+class UserCollection(BaseModel):
+    users: List[User]
+
+
+# ── Conversation starter output ───────────────────────────────────────────────
+class ConversationStarter(BaseModel):
+    prompt: str
+
+
+class ConversationStarterCollection(BaseModel):
+    conversationsStarters: List[ConversationStarter] = Field(
+        ..., alias="conversationsStarters"
+    )
+
+    class Config:
+        populate_by_name = True
diff --git a/server/genai/src/conversation_starter/__init__.py b/server/genai/src/conversation_starter/__init__.py
diff --git a/server/genai/src/conversation_starter/main.py b/server/genai/src/conversation_starter/main.py
