Got the basics of the product/API working. Just need to fine-tune the model

backend/app.py

@@ -1,18 +1,38 @@
-"""FastAPI backend for Précis."""
+"""FastAPI backend for Précis — powered by Ollama (phi4-mini:3.8b)."""
 
+import logging
+from typing import Optional
+
+import httpx
+from fastapi import FastAPI, HTTPException, UploadFile, File
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi import FastAPI, HTTPException, UploadFile, File, Form
 from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
-from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+OLLAMA_BASE_URL = "http://127.0.0.1:11434"
+OLLAMA_COMPLETIONS_URL = f"{OLLAMA_BASE_URL}/v1/completions"
+MODEL_NAME = "phi4-mini:3.8b"
+
+# Tokens to generate for the summary — keep short for speed
+MAX_SUMMARY_TOKENS = 120
+TEMPERATURE = 0.2
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# App
+# ---------------------------------------------------------------------------
 
 app = FastAPI(
     title="Précis API",
-    description="Content summarization API",
-    version="0.1.0"
+    description="Content summarisation service powered by phi4-mini via Ollama",
+    version="0.2.0",
 )
 
-# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -22,21 +42,85 @@ app.add_middleware(
 )
 
 
+# ---------------------------------------------------------------------------
+# Schemas
+# ---------------------------------------------------------------------------
 
 class YouTubeRequest(BaseModel):
     url: str
     max_length: Optional[int] = 512
 
+
 class TranscriptRequest(BaseModel):
     text: str
+    title: Optional[str] = None
     max_length: Optional[int] = 512
 
+
 class SummarizeResponse(BaseModel):
     summary: str
     success: bool
     source_type: str
+    model: str = MODEL_NAME
+
 
+# ---------------------------------------------------------------------------
+# Ollama helper
+# ---------------------------------------------------------------------------
 
+def _build_prompt(title: Optional[str], text: str) -> str:
+    header = f"Title: {title}\n" if title else ""
+    return (
+        "Summarise the following article in 2–4 clear, factual sentences. "
+        "Do not add opinions or commentary.\n\n"
+        f"{header}"
+        f"Article:\n{text}\n\n"
+        "Summary:"
+    )
+
+
+async def call_ollama(prompt: str, max_tokens: int = MAX_SUMMARY_TOKENS) -> str:
+    """Send a prompt to the local Ollama completions endpoint and return the text."""
+    payload = {
+        "model": MODEL_NAME,
+        "prompt": prompt,
+        "max_tokens": max_tokens,
+        "temperature": TEMPERATURE,
+        "stop": ["\n\n", "Article:", "Title:"],  # prevent runaway generation
+    }
+
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        try:
+            resp = await client.post(OLLAMA_COMPLETIONS_URL, json=payload)
+            resp.raise_for_status()
+        except httpx.ConnectError:
+            raise HTTPException(
+                status_code=503,
+                detail=(
+                    "Cannot reach Ollama at 127.0.0.1:11434. "
+                    "Make sure `ollama serve` is running."
+                ),
+            )
+        except httpx.HTTPStatusError as exc:
+            raise HTTPException(
+                status_code=502,
+                detail=f"Ollama returned an error: {exc.response.text}",
+            )
+
+    data = resp.json()
+    try:
+        return data["choices"][0]["text"].strip()
+    except (KeyError, IndexError) as exc:
+        logger.error("Unexpected Ollama response: %s", data)
+        raise HTTPException(
+            status_code=502,
+            detail=f"Unexpected response shape from Ollama: {exc}",
+        )
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
@@ -50,17 +134,20 @@ async def root():
                 body { font-family: system-ui; max-width: 800px; margin: 50px auto; padding: 20px; }
                 h1 { color: #333; }
                 code { background: #f4f4f4; padding: 2px 6px; border-radius: 3px; }
+                .model { color: #6366f1; font-weight: bold; }
             </style>
         </head>
         <body>
             <h1>Précis API</h1>
-            <p>Content summarization service</p>
+            <p>Model: <span class="model">phi4-mini:3.8b</span> via Ollama</p>
             <h2>Endpoints</h2>
             <ul>
-                <li><code>POST /summarize</code> - Summarize content from URL</li>
-                <li><code>GET /health</code> - Health check</li>
-                <li><code>GET /status</code> - Service status</li>
-                <li><code>GET /docs</code> - API documentation</li>
+                <li><code>POST /summarize/transcript</code> — Summarise raw text</li>
+                <li><code>POST /summarize/file</code> — Summarise a .txt file</li>
+                <li><code>POST /summarize/youtube</code> — Summarise a YouTube video (transcript required)</li>
+                <li><code>GET /health</code> — Health check</li>
+                <li><code>GET /status</code> — Service status</li>
+                <li><code>GET /docs</code> — Interactive API docs</li>
             </ul>
         </body>
     </html>
@@ -75,53 +162,77 @@ async def health():
 
 @app.get("/status")
 async def status():
-    """Service status endpoint."""
+    """Service status — also pings Ollama to confirm it is reachable."""
+    ollama_ok = False
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            r = await client.get(f"{OLLAMA_BASE_URL}/api/tags")
+            ollama_ok = r.status_code == 200
+    except Exception:
+        pass
+
     return {
         "service": "Précis API",
-        "version": "0.1.0",
-        "model": "Qwen/Qwen2.5-7B-Instruct",
-        "model_loaded": False,  # TODO: Track actual model state
-        "endpoints": ["/", "/health", "/status", "/summarize"]
+        "version": "0.2.0",
+        "model": MODEL_NAME,
+        "ollama_reachable": ollama_ok,
+        "endpoints": ["/", "/health", "/status", "/summarize/transcript",
+                      "/summarize/file", "/summarize/youtube"],
     }
 
 
-@app.post("/summarize/youtube", response_model=SummarizeResponse)
-async def summarize_youtube(request: YouTubeRequest):
-    """Summarize a YouTube video from its URL."""
-    # TODO: Implement YT transcript extraction and summarization
-    return SummarizeResponse(
-        summary=f"Summary for YouTube video at {request.url}. (Placeholder)",
-        success=True,
-        source_type="youtube"
-    )
-
 @app.post("/summarize/transcript", response_model=SummarizeResponse)
 async def summarize_transcript(request: TranscriptRequest):
-    """Summarize a provided transcript or article text."""
-    # TODO: Implement summarization
-    return SummarizeResponse(
-        summary=f"Summary for provided text ({len(request.text)} chars). (Placeholder)",
-        success=True,
-        source_type="transcript"
-    )
+    """Summarise a provided article or transcript."""
+    if not request.text.strip():
+        raise HTTPException(status_code=400, detail="text must not be empty")
+
+    prompt = _build_prompt(request.title, request.text)
+    summary = await call_ollama(prompt)
+
+    return SummarizeResponse(summary=summary, success=True, source_type="transcript")
+
 
 @app.post("/summarize/file", response_model=SummarizeResponse)
 async def summarize_file(file: UploadFile = File(...)):
-    """Summarize content from a .txt file."""
+    """Summarise content from an uploaded .txt file."""
     if not file.filename.endswith(".txt"):
         raise HTTPException(status_code=400, detail="Only .txt files are supported")
-    
+
     content = await file.read()
     text = content.decode("utf-8")
-    
-    # TODO: Implement summarization
-    return SummarizeResponse(
-        summary=f"Summary for file {file.filename} ({len(text)} chars). (Placeholder)",
-        success=True,
-        source_type="file"
+
+    if not text.strip():
+        raise HTTPException(status_code=400, detail="Uploaded file is empty")
+
+    prompt = _build_prompt(file.filename, text)
+    summary = await call_ollama(prompt)
+
+    return SummarizeResponse(summary=summary, success=True, source_type="file")
+
+
+@app.post("/summarize/youtube", response_model=SummarizeResponse)
+async def summarize_youtube(request: YouTubeRequest):
+    """
+    Summarise a YouTube video.
+
+    NOTE: Automatic transcript fetching is not yet implemented.
+    Pass the transcript text in a separate /summarize/transcript call,
+    or extend this endpoint with youtube-transcript-api.
+    """
+    # Placeholder — returns a clear message rather than silently lying
+    raise HTTPException(
+        status_code=501,
+        detail=(
+            "Automatic YouTube transcript fetching is not yet implemented. "
+            "Extract the transcript yourself and POST it to /summarize/transcript."
+        ),
     )
 
 
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
     import uvicorn

frontend/README.md

@@ -21,23 +21,13 @@ A GitHub-inspired dark theme frontend for the Précis content summarization API.
 npm install
 ```
 
-Or with Bun:
-
-```bash
-bun install
-```
-
 ### 2. Start the Development Server
 
 ```bash
 npm run dev
 ```
 
-Or with Bun:
-
-```bash
-bun run dev
-```
+(If you prefer a different m)
 
 The frontend will be available at [http://localhost:5173](http://localhost:5173).
 

frontend/src/App.css

@@ -262,4 +262,57 @@
 
 .footer a:hover {
   text-decoration: underline;
+}
+
+/* ── Inline result (transcript tab) ─────────────────────────────────────── */
+.inline-result {
+  margin-top: var(--spacing-3);
+  padding: var(--spacing-3) var(--spacing-4);
+  border-radius: var(--radius-1);
+  font-size: 13px;
+  line-height: 1.6;
+  display: flex;
+  align-items: flex-start;
+  gap: var(--spacing-2);
+  border: 1px solid transparent;
+}
+
+.inline-result--success {
+  background-color: rgba(46, 160, 67, 0.08);
+  border-color: rgba(46, 160, 67, 0.3);
+  color: var(--color-fg-default);
+  flex-direction: column;
+  gap: var(--spacing-2);
+}
+
+.inline-result--error {
+  background-color: rgba(248, 81, 73, 0.08);
+  border-color: rgba(248, 81, 73, 0.3);
+  color: var(--color-danger-fg);
+  align-items: center;
+}
+
+.inline-result--loading {
+  background-color: var(--color-canvas-inset);
+  border-color: var(--color-border-muted);
+  color: var(--color-fg-muted);
+  align-items: center;
+}
+
+.inline-result__label {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-1);
+  font-size: 12px;
+  font-weight: 600;
+  color: rgba(46, 160, 67, 0.9);
+  width: 100%;
+}
+
+.inline-result__text {
+  font-size: 14px;
+  line-height: 1.7;
+  color: var(--color-fg-default);
+  white-space: pre-wrap;
+  margin: 0;
 }

frontend/src/App.jsx

@@ -2,6 +2,8 @@ import { useState, useRef } from 'react'
 import './App.css'
 
 const API_BASE = 'http://localhost:8000'
+const OLLAMA_URL = 'http://127.0.0.1:11434/v1/completions'
+const MODEL_NAME = 'phi4-mini:3.8b'
 
 function App() {
   const [activeTab, setActiveTab] = useState('youtube')
@@ -13,6 +15,30 @@ function App() {
   const [error, setError] = useState(null)
   const fileInputRef = useRef(null)
 
+  const callOllama = async (text) => {
+    const prompt = `Summarise the following article in 2–4 clear, factual sentences. Do not add opinions or commentary.\n\nArticle:\n${text}\n\nSummary:`
+
+    const res = await fetch(OLLAMA_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: MODEL_NAME,
+        prompt,
+        max_tokens: 120,
+        temperature: 0.2,
+        stop: ['\n\n', 'Article:', 'Title:']
+      })
+    })
+
+    if (!res.ok) {
+      const body = await res.text()
+      throw new Error(`Ollama error (${res.status}): ${body}`)
+    }
+
+    const data = await res.json()
+    return data.choices[0].text.trim()
+  }
+
   const handleSubmit = async () => {
     setLoading(true)
     setError(null)
@@ -35,12 +61,8 @@ function App() {
         if (!transcript.trim()) {
           throw new Error('Please enter some text')
         }
-        const res = await fetch(`${API_BASE}/summarize/transcript`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ text: transcript })
-        })
-        result = await res.json()
+        const summary = await callOllama(transcript)
+        result = { summary, success: true, source_type: 'transcript', model: MODEL_NAME }
       } else if (activeTab === 'file') {
         if (!selectedFile) {
           throw new Error('Please select a file')
@@ -164,6 +186,30 @@ function App() {
                     />
                     <p className="form-hint">Paste any text content you want to summarize.</p>
                   </div>
+
+                  {/* Inline result — only shown when this tab triggered it */}
+                  {activeTab === 'transcript' && error && (
+                    <div className="inline-result inline-result--error fade-in">
+                      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"><circle cx="12" cy="12" r="10" /><line x1="12" y1="8" x2="12" y2="12" /><line x1="12" y1="16" x2="12.01" y2="16" /></svg>
+                      {error}
+                    </div>
+                  )}
+                  {activeTab === 'transcript' && loading && (
+                    <div className="inline-result inline-result--loading fade-in">
+                      <span className="loading-spinner" style={{ width: 14, height: 14 }} />
+                      Generating summary…
+                    </div>
+                  )}
+                  {activeTab === 'transcript' && response && !loading && (
+                    <div className="inline-result inline-result--success fade-in">
+                      <div className="inline-result__label">
+                        <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"><polyline points="20 6 9 17 4 12" /></svg>
+                        Summary
+                        <span className="response-badge" style={{ marginLeft: 'auto' }}>{response.model ?? 'phi4-mini'}</span>
+                      </div>
+                      <p className="inline-result__text">{response.summary}</p>
+                    </div>
+                  )}
                 </div>
 
                 {/* File Tab */}
@@ -248,8 +294,8 @@ function App() {
               </div>
             </div>
 
-            {/* Error display */}
-            {error && (
+            {/* Error display — for YouTube / File tabs only (transcript shows inline) */}
+            {error && activeTab !== 'transcript' && (
               <div className="response-section fade-in">
                 <div className="response-card" style={{ borderColor: 'var(--color-danger-fg)' }}>
                   <div className="response-header" style={{ borderColor: 'var(--color-danger-fg)' }}>
@@ -269,8 +315,8 @@ function App() {
               </div>
             )}
 
-            {/* Response display */}
-            {response && (
+            {/* Response display — for YouTube / File tabs only (transcript shows inline) */}
+            {response && activeTab !== 'transcript' && (
               <div className="response-section fade-in">
                 <div className="response-card">
                   <div className="response-header">

requirements.txt

@@ -1,4 +1,4 @@
-# Core ML
+# Core ML (training pipeline — not needed to run the API)
 torch
 transformers
 accelerate
@@ -10,3 +10,5 @@ sentencepiece
 # API
 fastapi
 uvicorn
+httpx          # async HTTP client for Ollama calls
+python-multipart  # required by FastAPI for file uploads