added AI plugin for sentiment and summarize endpoints

app/main.py

@@ -5,6 +5,7 @@ import sys
 
 import structlog
 from fastapi import FastAPI
+from dotenv import load_dotenv
 
 from app.routes import api_router
 
@@ -29,6 +30,8 @@ def configure_logging() -> None:
 
 
 def create_app() -> FastAPI:
+    # Load environment variables from a local .env file for development.
+    load_dotenv()
     configure_logging()
     app = FastAPI(title="Summarize & Sentiment API")
     app.include_router(api_router)

app/services/sentiment.py

@@ -1,28 +1,138 @@
 from __future__ import annotations
 
+import json
+import os
+import re
+from typing import Any
+
+from openai import OpenAI
+from dotenv import load_dotenv
+
 from app.schemas.models import SentimentLabel, SentimentResponse
 
+_DEFAULT_MODEL = "gpt-4.1-mini"
+
+
+def _normalize_sentiment_label(value: str) -> SentimentLabel:
+    """Map common model sentiment variants to supported labels."""
+    normalized = re.sub(r"[^a-z]+", "_", value.strip().lower()).strip("_")
+    if not normalized:
+        raise RuntimeError("Invalid sentiment label returned by model")
+
+    if normalized in {"positive", "pos", "somewhat_positive", "very_positive"}:
+        return SentimentLabel.POSITIVE
+    if normalized in {"negative", "neg", "somewhat_negative", "very_negative"}:
+        return SentimentLabel.NEGATIVE
+    if normalized in {"neutral", "mixed", "mixed_sentiment", "balanced"}:
+        return SentimentLabel.NEUTRAL
+
+    if "positive" in normalized:
+        return SentimentLabel.POSITIVE
+    if "negative" in normalized:
+        return SentimentLabel.NEGATIVE
+    if "neutral" in normalized or "mixed" in normalized:
+        return SentimentLabel.NEUTRAL
+
+    raise RuntimeError("Invalid sentiment label returned by model")
+
+
+def _extract_text_from_response(response: Any) -> str:
+    """Extract assistant text from OpenAI responses API output."""
+    output = getattr(response, "output", None) or []
+    chunks: list[str] = []
+
+    for item in output:
+        if getattr(item, "type", None) != "message":
+            continue
+        for content_part in getattr(item, "content", None) or []:
+            if getattr(content_part, "type", None) == "output_text":
+                text = getattr(content_part, "text", "")
+                if text:
+                    chunks.append(text)
+
+    return "\n".join(chunks).strip()
+
+
+def _parse_sentiment_response(raw_text: str) -> SentimentResponse:
+    """Parse and validate model JSON output."""
+    candidate = raw_text.strip()
+    if candidate.startswith("```"):
+        candidate = re.sub(r"^```(?:json)?\s*", "", candidate, flags=re.IGNORECASE)
+        candidate = re.sub(r"\s*```$", "", candidate)
+
+    # If extra text is present, recover the first JSON object.
+    if "{" in candidate and "}" in candidate:
+        first = candidate.find("{")
+        last = candidate.rfind("}")
+        candidate = candidate[first : last + 1]
+
+    try:
+        payload = json.loads(candidate)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError("Model did not return valid JSON for sentiment output") from exc
+
+    if not isinstance(payload, dict):
+        raise RuntimeError("Model response must be a JSON object")
+
+    sentiment_raw = str(payload.get("sentiment", ""))
+    sentiment = _normalize_sentiment_label(sentiment_raw)
+
+    confidence_raw = payload.get("confidence")
+    try:
+        confidence = float(confidence_raw)
+    except (TypeError, ValueError) as exc:
+        raise RuntimeError("Invalid confidence value returned by model") from exc
+
+    if confidence < 0.0 or confidence > 1.0:
+        raise RuntimeError("Confidence must be between 0.0 and 1.0")
+
+    explanation_raw = payload.get("explanation")
+    if not isinstance(explanation_raw, str) or not explanation_raw.strip():
+        raise RuntimeError("Explanation must be a non-empty string")
 
-def _analyze_sentiment(text: str) -> SentimentResponse:
-    """Placeholder heuristic; swap for a model or API as needed."""
-    lower = text.lower()
-    positive_hits = sum(1 for w in ("good", "great", "love", "excellent", "happy") if w in lower)
-    negative_hits = sum(1 for w in ("bad", "hate", "awful", "terrible", "sad") if w in lower)
-
-    if positive_hits > negative_hits:
-        return SentimentResponse(
-            sentiment=SentimentLabel.POSITIVE,
-            confidence=0.75,
-            explanation="More positive cue words than negative (placeholder).",
-        )
-    if negative_hits > positive_hits:
-        return SentimentResponse(
-            sentiment=SentimentLabel.NEGATIVE,
-            confidence=0.75,
-            explanation="More negative cue words than positive (placeholder).",
-        )
     return SentimentResponse(
-        sentiment=SentimentLabel.NEUTRAL,
-        confidence=0.5,
-        explanation="No strong positive/negative cues (placeholder).",
+        sentiment=sentiment,
+        confidence=confidence,
+        explanation=explanation_raw.strip(),
+    )
+
+
+def _analyze_sentiment(text: str) -> SentimentResponse:
+    """Analyze sentiment with OpenAI and return strict JSON fields."""
+    load_dotenv()
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY is not set")
+
+    model = os.getenv("OPENAI_MODEL", _DEFAULT_MODEL)
+    client = OpenAI(api_key=api_key)
+
+    response = client.responses.create(
+        model=model,
+        temperature=0,
+        input=[
+            {
+                "role": "system",
+                "content": (
+                    "You are a senior developer sentiment analysis assistant. "
+                    "Analyze sentiment and respond with strict JSON only."
+                ),
+            },
+            {
+                "role": "user",
+                "content": (
+                    "Analyze the sentiment of the text entered in JSON. "
+                    "Respond only in JSON with keys: sentiment, confidence, explanation. "
+                    "The sentiment value must be exactly one of: positive, negative, neutral. "
+                    "No extra text.\n\n"
+                    f"Text:\n{text}"
+                ),
+            },
+        ],
     )
+
+    raw_output = _extract_text_from_response(response)
+    if not raw_output:
+        raise RuntimeError("No sentiment analysis returned from model")
+
+    return _parse_sentiment_response(raw_output)

app/services/summarize.py

@@ -1,5 +1,64 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from openai import OpenAI
+from dotenv import load_dotenv
+
+_DEFAULT_MODEL = "gpt-4.1-mini"
+
+
+def _extract_text_from_response(response: Any) -> str:
+    """Extract assistant text from OpenAI responses API output."""
+    output = getattr(response, "output", None) or []
+    chunks: list[str] = []
+
+    for item in output:
+        if getattr(item, "type", None) != "message":
+            continue
+        for content_part in getattr(item, "content", None) or []:
+            if getattr(content_part, "type", None) == "output_text":
+                text = getattr(content_part, "text", "")
+                if text:
+                    chunks.append(text)
+
+    return "\n".join(chunks).strip()
+
+
 def _get_summary(text: str, max_length: int) -> str:
-    """Placeholder: replace with real summarization later."""
-    if len(text) <= max_length:
-        return text
-    return text[:max_length] + "..."
+    """Generate concise summary text with an OpenAI model."""
+    load_dotenv()
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY is not set")
+
+    model = os.getenv("OPENAI_MODEL", _DEFAULT_MODEL)
+    client = OpenAI(api_key=api_key)
+
+    response = client.responses.create(
+        model=model,
+        temperature=0,
+        input=[
+            {
+                "role": "system",
+                "content": (
+                    "You are a concise summarization assistant. "
+                    "Return only the summary text with no preamble."
+                ),
+            },
+            {
+                "role": "user",
+                "content": (
+                    f"Summarize the text entered in JSON in under {max_length} words. "
+                    "Return only the summary, no extra commentary.\n\n"
+                    f"Text:\n{text}"
+                ),
+            },
+        ],
+    )
+
+    summary = _extract_text_from_response(response)
+    if not summary:
+        raise RuntimeError("No summary text returned from model")
+    return summary

requirements.txt

@@ -2,3 +2,5 @@ fastapi>=0.115.0
 uvicorn[standard]>=0.32.0
 pydantic>=2.10.0
 structlog>=24.4.0
+openai>=1.75.0
+python-dotenv>=1.0.1