chore: initialize FastAPI backend project structure and testing setup

.gitignore

@@ -0,0 +1,61 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Logs
+*.log
+logs/
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Docker
+.dockerignore

BACKEND_PLAN.md

@@ -0,0 +1,311 @@
+# Text Summarizer Backend - Development Plan
+
+## Overview
+A minimal FastAPI backend for text summarization using local Ollama, designed to be callable from an Android app and extensible for cloud hosting.
+
+## Architecture Goals
+- **Local-first**: Use Ollama running locally for privacy and cost control
+- **Cloud-ready**: Structure code to easily deploy to cloud later
+- **Minimal v1**: Focus on core summarization functionality
+- **Android-friendly**: RESTful API optimized for mobile app consumption
+
+## Technology Stack
+- **Backend**: FastAPI + Python
+- **LLM**: Ollama (local)
+- **Server**: Uvicorn
+- **Validation**: Pydantic
+- **Testing**: Pytest + pytest-asyncio + httpx (for async testing)
+- **Containerization**: Docker (for cloud deployment)
+
+## Project Structure
+```
+app/
+├── main.py                 # FastAPI app entry point
+├── api/
+│   └── v1/
+│       ├── routes.py       # API route definitions
+│       └── schemas.py      # Pydantic models
+├── services/
+│   └── summarizer.py       # Ollama integration
+├── core/
+│   ├── config.py          # Configuration management
+│   └── logging.py         # Logging setup
+tests/
+├── test_api.py            # API endpoint tests
+├── test_services.py       # Service layer tests
+├── test_schemas.py        # Pydantic model tests
+├── test_config.py         # Configuration tests
+└── conftest.py           # Test configuration and fixtures
+requirements.txt
+Dockerfile
+docker-compose.yml
+README.md
+```
+
+## API Contract (v1)
+
+### POST /api/v1/summarize
+**Request:**
+```json
+{
+  "text": "string (required)",
+  "max_tokens": 256,
+  "prompt": "Summarize concisely."
+}
+```
+
+**Response:**
+```json
+{
+  "summary": "string",
+  "model": "llama3.1:8b",
+  "tokens_used": 512,
+  "latency_ms": 1234
+}
+```
+
+### GET /health
+**Response:**
+```json
+{
+  "status": "ok",
+  "ollama": "reachable"
+}
+```
+
+## Development Phases
+
+### Phase 1: Foundation
+- [ ] Project scaffold and directory structure
+- [ ] Core dependencies and requirements.txt (including test dependencies)
+- [ ] Basic FastAPI app setup
+- [ ] Configuration management with environment variables
+- [ ] Logging setup
+- [ ] Health check endpoint
+- [ ] Basic test setup and configuration
+
+### Phase 2: Core Feature
+- [ ] Pydantic schemas for request/response
+- [ ] Unit tests for schemas (validation, serialization)
+- [ ] Ollama service integration
+- [ ] Unit tests for Ollama service (mocked)
+- [ ] Summarization endpoint implementation
+- [ ] Integration tests for API endpoints
+- [ ] Input validation and error handling
+- [ ] Basic request/response logging
+
+### Phase 3: Quality & DX
+- [ ] Error handling middleware
+- [ ] Request ID middleware
+- [ ] Input size limits and validation
+- [ ] Rate limiting (optional for v1)
+- [ ] Test coverage analysis and improvement
+- [ ] Performance tests for summarization endpoint
+
+### Phase 4: Cloud-Ready Structure
+- [ ] Dockerfile for containerization
+- [ ] docker-compose.yml for local development
+- [ ] Environment-based configuration
+- [ ] CORS configuration for Android app
+- [ ] Security headers and API key support (optional)
+- [ ] Metrics endpoint (optional)
+
+### Phase 5: Documentation & Examples
+- [ ] Comprehensive README with setup instructions
+- [ ] API documentation (FastAPI auto-docs)
+- [ ] Example curl commands
+- [ ] Android client integration examples
+- [ ] Deployment guide for cloud hosting
+
+## Configuration
+
+### Environment Variables
+```bash
+# Ollama Configuration
+OLLAMA_MODEL=llama3.1:8b
+OLLAMA_HOST=http://127.0.0.1:11434
+OLLAMA_TIMEOUT=30
+
+# Server Configuration
+SERVER_HOST=127.0.0.1
+SERVER_PORT=8000
+LOG_LEVEL=INFO
+
+# Optional: API Security
+API_KEY_ENABLED=false
+API_KEY=your-secret-key
+
+# Optional: Rate Limiting
+RATE_LIMIT_ENABLED=false
+RATE_LIMIT_REQUESTS=60
+RATE_LIMIT_WINDOW=60
+```
+
+## Local Development Setup
+
+### Prerequisites
+1. Install Ollama:
+   ```bash
+   # macOS
+   brew install ollama
+   
+   # Or download from https://ollama.ai
+   ```
+
+2. Start Ollama service:
+   ```bash
+   ollama serve
+   ```
+
+3. Pull a model:
+   ```bash
+   ollama pull llama3.1:8b
+   # or
+   ollama pull mistral
+   ```
+
+### Running the API
+```bash
+# Create virtual environment
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set environment variables
+export OLLAMA_MODEL=llama3.1:8b
+
+# Run the server
+uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
+```
+
+### Testing the API
+```bash
+# Health check
+curl http://127.0.0.1:8000/health
+
+# Summarize text
+curl -X POST http://127.0.0.1:8000/api/v1/summarize \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Your long text to summarize here..."}'
+```
+
+### Running Tests
+```bash
+# Run all tests
+pytest
+
+# Run tests with coverage
+pytest --cov=app --cov-report=html --cov-report=term
+
+# Run specific test file
+pytest tests/test_api.py
+
+# Run tests with verbose output
+pytest -v
+
+# Run tests and stop on first failure
+pytest -x
+```
+
+## Testing Strategy
+
+### Test Types
+1. **Unit Tests**
+   - Pydantic model validation
+   - Service layer logic (with mocked Ollama)
+   - Configuration loading
+   - Utility functions
+
+2. **Integration Tests**
+   - API endpoint testing with TestClient
+   - End-to-end summarization flow
+   - Error handling scenarios
+   - Health check functionality
+
+3. **Mock Strategy**
+   - Mock Ollama HTTP calls using `httpx` or `responses`
+   - Mock external dependencies
+   - Use fixtures for common test data
+
+### Test Coverage Goals
+- **Minimum 90% code coverage**
+- **100% coverage for critical paths** (API endpoints, error handling)
+- **All edge cases tested** (empty input, large input, network failures)
+
+### Test Data
+```python
+# Example test fixtures
+SAMPLE_TEXT = "This is a long text that needs to be summarized..."
+SAMPLE_SUMMARY = "This text discusses summarization."
+MOCK_OLLAMA_RESPONSE = {
+    "model": "llama3.1:8b",
+    "response": SAMPLE_SUMMARY,
+    "done": True
+}
+```
+
+### Continuous Testing
+- Tests run on every code change
+- Pre-commit hooks for test execution
+- CI/CD pipeline integration ready
+
+## Android Integration
+
+### Example Android HTTP Client
+```kotlin
+// Using Retrofit or OkHttp
+data class SummarizeRequest(
+    val text: String,
+    val max_tokens: Int = 256,
+    val prompt: String = "Summarize concisely."
+)
+
+data class SummarizeResponse(
+    val summary: String,
+    val model: String,
+    val tokens_used: Int,
+    val latency_ms: Int
+)
+
+// API call
+@POST("api/v1/summarize")
+suspend fun summarize(@Body request: SummarizeRequest): SummarizeResponse
+```
+
+## Cloud Deployment Considerations
+
+### Future Extensions
+- **Authentication**: API key or OAuth2
+- **Rate Limiting**: Redis-based distributed rate limiting
+- **Monitoring**: Prometheus metrics, health checks
+- **Scaling**: Multiple replicas, load balancing
+- **Database**: Usage tracking, user management
+- **Caching**: Redis for response caching
+- **Security**: HTTPS, input sanitization, CORS policies
+
+### Deployment Options
+- **Docker**: Containerized deployment
+- **Cloud Platforms**: AWS, GCP, Azure, Railway, Render
+- **Serverless**: AWS Lambda, Vercel Functions (with Ollama API)
+- **VPS**: DigitalOcean, Linode with Docker
+
+## Success Criteria
+- [ ] API responds to health checks
+- [ ] Successfully summarizes text via Ollama
+- [ ] Handles errors gracefully
+- [ ] Works with Android app
+- [ ] Can be containerized
+- [ ] **All tests pass with >90% coverage**
+- [ ] Documentation is complete
+
+## Future Enhancements (Post-v1)
+- [ ] Streaming responses
+- [ ] Batch summarization
+- [ ] Multiple model support
+- [ ] Prompt templates and presets
+- [ ] Usage analytics
+- [ ] Multi-language support
+- [ ] Advanced rate limiting
+- [ ] User authentication and authorization

app/__init__.py

@@ -0,0 +1 @@
+# Text Summarizer Backend API

app/api/__init__.py

@@ -0,0 +1 @@
+# API package

app/api/v1/__init__.py

@@ -0,0 +1 @@
+# API v1 package

app/api/v1/routes.py

@@ -0,0 +1,13 @@
+"""
+API v1 routes for the text summarizer backend.
+"""
+from fastapi import APIRouter
+
+# Create API router
+api_router = APIRouter()
+
+# Import and include route modules here
+# from .endpoints import summarize, health
+
+# api_router.include_router(summarize.router, prefix="/summarize", tags=["summarize"])
+# api_router.include_router(health.router, prefix="/health", tags=["health"])

app/api/v1/schemas.py

@@ -0,0 +1,50 @@
+"""
+Pydantic schemas for API request/response models.
+"""
+from typing import Optional
+from pydantic import BaseModel, Field, validator
+
+
+class SummarizeRequest(BaseModel):
+    """Request schema for text summarization."""
+    
+    text: str = Field(..., min_length=1, max_length=32000, description="Text to summarize")
+    max_tokens: Optional[int] = Field(default=256, ge=1, le=2048, description="Maximum tokens for summary")
+    prompt: Optional[str] = Field(
+        default="Summarize the following text concisely:",
+        max_length=500,
+        description="Custom prompt for summarization"
+    )
+    
+    @validator('text')
+    def validate_text(cls, v):
+        """Validate text input."""
+        if not v.strip():
+            raise ValueError("Text cannot be empty or only whitespace")
+        return v.strip()
+
+
+class SummarizeResponse(BaseModel):
+    """Response schema for text summarization."""
+    
+    summary: str = Field(..., description="Generated summary")
+    model: str = Field(..., description="Model used for summarization")
+    tokens_used: Optional[int] = Field(None, description="Number of tokens used")
+    latency_ms: Optional[float] = Field(None, description="Processing time in milliseconds")
+
+
+class HealthResponse(BaseModel):
+    """Response schema for health check."""
+    
+    status: str = Field(..., description="Service status")
+    service: str = Field(..., description="Service name")
+    version: str = Field(..., description="Service version")
+    ollama: Optional[str] = Field(None, description="Ollama service status")
+
+
+class ErrorResponse(BaseModel):
+    """Error response schema."""
+    
+    detail: str = Field(..., description="Error message")
+    code: Optional[str] = Field(None, description="Error code")
+    request_id: Optional[str] = Field(None, description="Request ID for tracking")

app/core/__init__.py

@@ -0,0 +1 @@
+# Core package

app/core/config.py

@@ -0,0 +1,41 @@
+"""
+Configuration management for the text summarizer backend.
+"""
+import os
+from typing import Optional
+from pydantic import BaseSettings, Field
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+    
+    # Ollama Configuration
+    ollama_model: str = Field(default="llama3.1:8b", env="OLLAMA_MODEL")
+    ollama_host: str = Field(default="http://127.0.0.1:11434", env="OLLAMA_HOST")
+    ollama_timeout: int = Field(default=30, env="OLLAMA_TIMEOUT")
+    
+    # Server Configuration
+    server_host: str = Field(default="127.0.0.1", env="SERVER_HOST")
+    server_port: int = Field(default=8000, env="SERVER_PORT")
+    log_level: str = Field(default="INFO", env="LOG_LEVEL")
+    
+    # Optional: API Security
+    api_key_enabled: bool = Field(default=False, env="API_KEY_ENABLED")
+    api_key: Optional[str] = Field(default=None, env="API_KEY")
+    
+    # Optional: Rate Limiting
+    rate_limit_enabled: bool = Field(default=False, env="RATE_LIMIT_ENABLED")
+    rate_limit_requests: int = Field(default=60, env="RATE_LIMIT_REQUESTS")
+    rate_limit_window: int = Field(default=60, env="RATE_LIMIT_WINDOW")
+    
+    # Input validation
+    max_text_length: int = Field(default=32000, env="MAX_TEXT_LENGTH")  # ~32KB
+    max_tokens_default: int = Field(default=256, env="MAX_TOKENS_DEFAULT")
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+
+# Global settings instance
+settings = Settings()

app/core/logging.py

@@ -0,0 +1,51 @@
+"""
+Logging configuration for the text summarizer backend.
+"""
+import logging
+import sys
+from typing import Any, Dict
+from app.core.config import settings
+
+
+def setup_logging() -> None:
+    """Set up logging configuration."""
+    logging.basicConfig(
+        level=getattr(logging, settings.log_level.upper()),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(sys.stdout),
+        ]
+    )
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance."""
+    return logging.getLogger(name)
+
+
+class RequestLogger:
+    """Logger for request/response logging."""
+    
+    def __init__(self, logger: logging.Logger):
+        self.logger = logger
+    
+    def log_request(self, method: str, path: str, request_id: str, **kwargs: Any) -> None:
+        """Log incoming request."""
+        self.logger.info(
+            f"Request {request_id}: {method} {path}",
+            extra={"request_id": request_id, "method": method, "path": path, **kwargs}
+        )
+    
+    def log_response(self, request_id: str, status_code: int, duration_ms: float, **kwargs: Any) -> None:
+        """Log response."""
+        self.logger.info(
+            f"Response {request_id}: {status_code} ({duration_ms:.2f}ms)",
+            extra={"request_id": request_id, "status_code": status_code, "duration_ms": duration_ms, **kwargs}
+        )
+    
+    def log_error(self, request_id: str, error: str, **kwargs: Any) -> None:
+        """Log error."""
+        self.logger.error(
+            f"Error {request_id}: {error}",
+            extra={"request_id": request_id, "error": error, **kwargs}
+        )

app/main.py

@@ -0,0 +1,68 @@
+"""
+Main FastAPI application for text summarizer backend.
+"""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.config import settings
+from app.core.logging import setup_logging, get_logger
+from app.api.v1.routes import api_router
+
+# Set up logging
+setup_logging()
+logger = get_logger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="Text Summarizer API",
+    description="A FastAPI backend for text summarization using Ollama",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include API routes
+app.include_router(api_router, prefix="/api/v1")
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Application startup event."""
+    logger.info("Starting Text Summarizer API")
+    logger.info(f"Ollama host: {settings.ollama_host}")
+    logger.info(f"Ollama model: {settings.ollama_model}")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Application shutdown event."""
+    logger.info("Shutting down Text Summarizer API")
+
+
+@app.get("/")
+async def root():
+    """Root endpoint."""
+    return {
+        "message": "Text Summarizer API",
+        "version": "1.0.0",
+        "docs": "/docs"
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "ok",
+        "service": "text-summarizer-api",
+        "version": "1.0.0"
+    }

app/services/__init__.py

@@ -0,0 +1 @@
+# Services package

app/services/summarizer.py

@@ -0,0 +1,104 @@
+"""
+Ollama service integration for text summarization.
+"""
+import time
+from typing import Dict, Any, Optional
+import httpx
+from app.core.config import settings
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class OllamaService:
+    """Service for interacting with Ollama API."""
+    
+    def __init__(self):
+        self.base_url = settings.ollama_host
+        self.model = settings.ollama_model
+        self.timeout = settings.ollama_timeout
+    
+    async def summarize_text(
+        self, 
+        text: str, 
+        max_tokens: int = 256, 
+        prompt: str = "Summarize the following text concisely:"
+    ) -> Dict[str, Any]:
+        """
+        Summarize text using Ollama.
+        
+        Args:
+            text: Text to summarize
+            max_tokens: Maximum tokens for summary
+            prompt: Custom prompt for summarization
+            
+        Returns:
+            Dictionary containing summary and metadata
+            
+        Raises:
+            httpx.HTTPError: If Ollama API call fails
+        """
+        start_time = time.time()
+        
+        # Prepare the full prompt
+        full_prompt = f"{prompt}\n\n{text}"
+        
+        # Prepare request payload
+        payload = {
+            "model": self.model,
+            "prompt": full_prompt,
+            "stream": False,
+            "options": {
+                "num_predict": max_tokens,
+                "temperature": 0.3,  # Lower temperature for more consistent summaries
+            }
+        }
+        
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(
+                    f"{self.base_url}/api/generate",
+                    json=payload
+                )
+                response.raise_for_status()
+                
+                result = response.json()
+                
+                # Calculate processing time
+                latency_ms = (time.time() - start_time) * 1000
+                
+                return {
+                    "summary": result.get("response", "").strip(),
+                    "model": self.model,
+                    "tokens_used": result.get("eval_count", 0),
+                    "latency_ms": round(latency_ms, 2)
+                }
+                
+        except httpx.TimeoutException:
+            logger.error(f"Timeout calling Ollama API after {self.timeout}s")
+            raise httpx.HTTPError("Ollama API timeout")
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error calling Ollama API: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error calling Ollama API: {e}")
+            raise httpx.HTTPError(f"Ollama API error: {str(e)}")
+    
+    async def check_health(self) -> bool:
+        """
+        Check if Ollama service is available.
+        
+        Returns:
+            True if Ollama is reachable, False otherwise
+        """
+        try:
+            async with httpx.AsyncClient(timeout=5) as client:
+                response = await client.get(f"{self.base_url}/api/tags")
+                return response.status_code == 200
+        except Exception as e:
+            logger.warning(f"Ollama health check failed: {e}")
+            return False
+
+
+# Global service instance
+ollama_service = OllamaService()

pytest.ini

@@ -0,0 +1,20 @@
+[tool:pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts = 
+    -v
+    --tb=short
+    --strict-markers
+    --disable-warnings
+    --cov=app
+    --cov-report=term-missing
+    --cov-report=html:htmlcov
+    --cov-fail-under=90
+markers =
+    unit: Unit tests
+    integration: Integration tests
+    slow: Slow running tests
+    ollama: Tests that require Ollama service
+asyncio_mode = auto

requirements.txt

@@ -0,0 +1,26 @@
+# FastAPI and server
+fastapi>=0.95.0,<0.100.0
+uvicorn[standard]>=0.20.0,<0.25.0
+
+# HTTP client for Ollama
+httpx>=0.24.0,<0.26.0
+
+# Data validation
+pydantic>=1.10.0,<2.0.0
+
+# Environment management
+python-dotenv>=0.19.0,<1.0.0
+
+# Testing
+pytest>=7.0.0,<8.0.0
+pytest-asyncio>=0.20.0,<0.22.0
+pytest-cov>=4.0.0,<5.0.0
+pytest-mock>=3.10.0,<4.0.0
+
+# Development tools
+black>=22.0.0,<24.0.0
+isort>=5.10.0,<6.0.0
+flake8>=5.0.0,<7.0.0
+
+# Optional: for better performance
+uvloop>=0.17.0,<0.20.0

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

tests/conftest.py

@@ -0,0 +1,93 @@
+"""
+Test configuration and fixtures for the text summarizer backend.
+"""
+import pytest
+import asyncio
+from typing import AsyncGenerator, Generator
+from httpx import AsyncClient
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+
+@pytest.fixture(scope="session")
+def event_loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
+    """Create an instance of the default event loop for the test session."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+@pytest.fixture
+def client() -> TestClient:
+    """Create a test client for FastAPI app."""
+    return TestClient(app)
+
+
+@pytest.fixture
+async def async_client() -> AsyncGenerator[AsyncClient, None]:
+    """Create an async test client for FastAPI app."""
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        yield ac
+
+
+# Test data fixtures
+@pytest.fixture
+def sample_text() -> str:
+    """Sample text for testing summarization."""
+    return """
+    Artificial intelligence (AI) is intelligence demonstrated by machines, 
+    in contrast to the natural intelligence displayed by humans and animals. 
+    Leading AI textbooks define the field as the study of "intelligent agents": 
+    any device that perceives its environment and takes actions that maximize 
+    its chance of successfully achieving its goals. The term "artificial intelligence" 
+    is often used to describe machines that mimic "cognitive" functions that humans 
+    associate with the human mind, such as "learning" and "problem solving".
+    """
+
+
+@pytest.fixture
+def sample_summary() -> str:
+    """Expected summary for sample text."""
+    return "AI is machine intelligence that mimics human cognitive functions like learning and problem-solving."
+
+
+@pytest.fixture
+def mock_ollama_response() -> dict:
+    """Mock response from Ollama API."""
+    return {
+        "model": "llama3.1:8b",
+        "response": "AI is machine intelligence that mimics human cognitive functions like learning and problem-solving.",
+        "done": True,
+        "context": [],
+        "total_duration": 1234567890,
+        "load_duration": 123456789,
+        "prompt_eval_count": 50,
+        "prompt_eval_duration": 123456789,
+        "eval_count": 20,
+        "eval_duration": 123456789
+    }
+
+
+@pytest.fixture
+def empty_text() -> str:
+    """Empty text for testing validation."""
+    return ""
+
+
+@pytest.fixture
+def very_long_text() -> str:
+    """Very long text for testing size limits."""
+    return "This is a test. " * 1000  # ~15KB of text
+
+
+# Environment fixtures
+@pytest.fixture
+def test_env_vars(monkeypatch):
+    """Set test environment variables."""
+    monkeypatch.setenv("OLLAMA_MODEL", "llama3.1:8b")
+    monkeypatch.setenv("OLLAMA_HOST", "http://127.0.0.1:11434")
+    monkeypatch.setenv("OLLAMA_TIMEOUT", "30")
+    monkeypatch.setenv("SERVER_HOST", "127.0.0.1")
+    monkeypatch.setenv("SERVER_PORT", "8000")
+    monkeypatch.setenv("LOG_LEVEL", "INFO")

tests/test_config.py

@@ -0,0 +1,40 @@
+"""
+Tests for configuration management.
+"""
+import pytest
+from app.core.config import Settings, settings
+
+
+class TestSettings:
+    """Test configuration settings."""
+    
+    def test_default_settings(self):
+        """Test default configuration values."""
+        test_settings = Settings()
+        
+        assert test_settings.ollama_model == "llama3.1:8b"
+        assert test_settings.ollama_host == "http://127.0.0.1:11434"
+        assert test_settings.ollama_timeout == 30
+        assert test_settings.server_host == "127.0.0.1"
+        assert test_settings.server_port == 8000
+        assert test_settings.log_level == "INFO"
+        assert test_settings.api_key_enabled is False
+        assert test_settings.rate_limit_enabled is False
+        assert test_settings.max_text_length == 32000
+        assert test_settings.max_tokens_default == 256
+    
+    def test_environment_override(self, test_env_vars):
+        """Test that environment variables override defaults."""
+        test_settings = Settings()
+        
+        assert test_settings.ollama_model == "llama3.1:8b"
+        assert test_settings.ollama_host == "http://127.0.0.1:11434"
+        assert test_settings.ollama_timeout == 30
+        assert test_settings.server_host == "127.0.0.1"
+        assert test_settings.server_port == 8000
+        assert test_settings.log_level == "INFO"
+    
+    def test_global_settings_instance(self):
+        """Test that global settings instance exists."""
+        assert settings is not None
+        assert isinstance(settings, Settings)

tests/test_main.py

@@ -0,0 +1,40 @@
+"""
+Tests for main FastAPI application.
+"""
+import pytest
+from fastapi.testclient import TestClient
+from app.main import app
+
+
+class TestMainApp:
+    """Test main FastAPI application."""
+    
+    def test_root_endpoint(self, client):
+        """Test root endpoint."""
+        response = client.get("/")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["message"] == "Text Summarizer API"
+        assert data["version"] == "1.0.0"
+        assert data["docs"] == "/docs"
+    
+    def test_health_endpoint(self, client):
+        """Test health check endpoint."""
+        response = client.get("/health")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "ok"
+        assert data["service"] == "text-summarizer-api"
+        assert data["version"] == "1.0.0"
+    
+    def test_docs_endpoint(self, client):
+        """Test that docs endpoint is accessible."""
+        response = client.get("/docs")
+        assert response.status_code == 200
+    
+    def test_redoc_endpoint(self, client):
+        """Test that redoc endpoint is accessible."""
+        response = client.get("/redoc")
+        assert response.status_code == 200

tests/test_schemas.py

@@ -0,0 +1,147 @@
+"""
+Tests for Pydantic schemas.
+"""
+import pytest
+from pydantic import ValidationError
+from app.api.v1.schemas import SummarizeRequest, SummarizeResponse, HealthResponse, ErrorResponse
+
+
+class TestSummarizeRequest:
+    """Test SummarizeRequest schema."""
+    
+    def test_valid_request(self, sample_text):
+        """Test valid request creation."""
+        request = SummarizeRequest(text=sample_text)
+        
+        assert request.text == sample_text.strip()
+        assert request.max_tokens == 256
+        assert request.prompt == "Summarize the following text concisely:"
+    
+    def test_custom_parameters(self):
+        """Test request with custom parameters."""
+        text = "Test text"
+        request = SummarizeRequest(
+            text=text,
+            max_tokens=512,
+            prompt="Custom prompt"
+        )
+        
+        assert request.text == text
+        assert request.max_tokens == 512
+        assert request.prompt == "Custom prompt"
+    
+    def test_empty_text_validation(self):
+        """Test validation of empty text."""
+        with pytest.raises(ValidationError) as exc_info:
+            SummarizeRequest(text="")
+        
+        # Check that validation error occurs (Pydantic v1 uses different error messages)
+        assert "ensure this value has at least 1 characters" in str(exc_info.value)
+    
+    def test_whitespace_only_text_validation(self):
+        """Test validation of whitespace-only text."""
+        with pytest.raises(ValidationError) as exc_info:
+            SummarizeRequest(text="   \n\t   ")
+        
+        assert "Text cannot be empty" in str(exc_info.value)
+    
+    def test_text_stripping(self):
+        """Test that text is stripped of leading/trailing whitespace."""
+        text = "  Test text  "
+        request = SummarizeRequest(text=text)
+        
+        assert request.text == "Test text"
+    
+    def test_max_tokens_validation(self):
+        """Test max_tokens validation."""
+        # Valid range
+        request = SummarizeRequest(text="test", max_tokens=1)
+        assert request.max_tokens == 1
+        
+        request = SummarizeRequest(text="test", max_tokens=2048)
+        assert request.max_tokens == 2048
+        
+        # Invalid range
+        with pytest.raises(ValidationError):
+            SummarizeRequest(text="test", max_tokens=0)
+        
+        with pytest.raises(ValidationError):
+            SummarizeRequest(text="test", max_tokens=2049)
+    
+    def test_prompt_length_validation(self):
+        """Test prompt length validation."""
+        long_prompt = "x" * 501
+        with pytest.raises(ValidationError):
+            SummarizeRequest(text="test", prompt=long_prompt)
+
+
+class TestSummarizeResponse:
+    """Test SummarizeResponse schema."""
+    
+    def test_valid_response(self, sample_summary):
+        """Test valid response creation."""
+        response = SummarizeResponse(
+            summary=sample_summary,
+            model="llama3.1:8b",
+            tokens_used=50,
+            latency_ms=1234.5
+        )
+        
+        assert response.summary == sample_summary
+        assert response.model == "llama3.1:8b"
+        assert response.tokens_used == 50
+        assert response.latency_ms == 1234.5
+    
+    def test_minimal_response(self):
+        """Test response with minimal required fields."""
+        response = SummarizeResponse(
+            summary="Test summary",
+            model="test-model"
+        )
+        
+        assert response.summary == "Test summary"
+        assert response.model == "test-model"
+        assert response.tokens_used is None
+        assert response.latency_ms is None
+
+
+class TestHealthResponse:
+    """Test HealthResponse schema."""
+    
+    def test_valid_health_response(self):
+        """Test valid health response creation."""
+        response = HealthResponse(
+            status="ok",
+            service="text-summarizer-api",
+            version="1.0.0",
+            ollama="reachable"
+        )
+        
+        assert response.status == "ok"
+        assert response.service == "text-summarizer-api"
+        assert response.version == "1.0.0"
+        assert response.ollama == "reachable"
+
+
+class TestErrorResponse:
+    """Test ErrorResponse schema."""
+    
+    def test_valid_error_response(self):
+        """Test valid error response creation."""
+        response = ErrorResponse(
+            detail="Something went wrong",
+            code="INTERNAL_ERROR",
+            request_id="req-123"
+        )
+        
+        assert response.detail == "Something went wrong"
+        assert response.code == "INTERNAL_ERROR"
+        assert response.request_id == "req-123"
+    
+    def test_minimal_error_response(self):
+        """Test error response with minimal fields."""
+        response = ErrorResponse(detail="Error occurred")
+        
+        assert response.detail == "Error occurred"
+        assert response.code is None
+        assert response.request_id is None

tests/test_services.py

@@ -0,0 +1,132 @@
+"""
+Tests for service layer.
+"""
+import pytest
+from unittest.mock import patch, MagicMock
+import httpx
+from app.services.summarizer import OllamaService
+
+
+class StubAsyncResponse:
+    """A minimal stub of an httpx.Response-like object for testing."""
+
+    def __init__(self, json_data=None, status_code=200, raise_for_status_exc=None):
+        self._json_data = json_data or {}
+        self.status_code = status_code
+        self._raise_for_status_exc = raise_for_status_exc
+
+    def json(self):
+        return self._json_data
+
+    def raise_for_status(self):
+        if self._raise_for_status_exc is not None:
+            raise self._raise_for_status_exc
+
+
+class StubAsyncClient:
+    """An async context manager stub that mimics httpx.AsyncClient for tests."""
+
+    def __init__(self, post_result=None, post_exc=None, get_result=None, get_exc=None, *args, **kwargs):
+        self._post_result = post_result
+        self._post_exc = post_exc
+        self._get_result = get_result
+        self._get_exc = get_exc
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return False
+
+    async def post(self, *args, **kwargs):
+        if self._post_exc is not None:
+            raise self._post_exc
+        return self._post_result or StubAsyncResponse()
+
+    async def get(self, *args, **kwargs):
+        if self._get_exc is not None:
+            raise self._get_exc
+        return self._get_result or StubAsyncResponse(status_code=200)
+
+
+class TestOllamaService:
+    """Test Ollama service."""
+    
+    @pytest.fixture
+    def ollama_service(self):
+        """Create Ollama service instance."""
+        return OllamaService()
+    
+    def test_service_initialization(self, ollama_service):
+        """Test service initialization."""
+        assert ollama_service.base_url == "http://127.0.0.1:11434"
+        assert ollama_service.model == "llama3.1:8b"
+        assert ollama_service.timeout == 30
+    
+    @pytest.mark.asyncio
+    async def test_summarize_text_success(self, ollama_service, mock_ollama_response):
+        """Test successful text summarization."""
+        stub_response = StubAsyncResponse(json_data=mock_ollama_response)
+        with patch('httpx.AsyncClient', return_value=StubAsyncClient(post_result=stub_response)):
+            result = await ollama_service.summarize_text("Test text")
+            
+            assert result["summary"] == mock_ollama_response["response"]
+            assert result["model"] == "llama3.1:8b"
+            assert result["tokens_used"] == mock_ollama_response["eval_count"]
+            assert "latency_ms" in result
+    
+    @pytest.mark.asyncio
+    async def test_summarize_text_with_custom_params(self, ollama_service, mock_ollama_response):
+        """Test summarization with custom parameters."""
+        stub_response = StubAsyncResponse(json_data=mock_ollama_response)
+        # Patch with a factory to capture payload for assertion
+        captured = {}
+
+        class CapturePostClient(StubAsyncClient):
+            async def post(self, *args, **kwargs):
+                captured['json'] = kwargs.get('json')
+                return await super().post(*args, **kwargs)
+
+        with patch('httpx.AsyncClient', return_value=CapturePostClient(post_result=stub_response)):
+            result = await ollama_service.summarize_text(
+                "Test text",
+                max_tokens=512,
+                prompt="Custom prompt"
+            )
+
+            assert result["summary"] == mock_ollama_response["response"]
+            # Verify captured payload
+            payload = captured['json']
+            assert payload["options"]["num_predict"] == 512
+            assert "Custom prompt" in payload["prompt"]
+    
+    @pytest.mark.asyncio
+    async def test_summarize_text_timeout(self, ollama_service):
+        """Test timeout handling."""
+        with patch('httpx.AsyncClient', return_value=StubAsyncClient(post_exc=httpx.TimeoutException("Timeout"))):
+            with pytest.raises(httpx.HTTPError, match="Ollama API timeout"):
+                await ollama_service.summarize_text("Test text")
+    
+    @pytest.mark.asyncio
+    async def test_summarize_text_http_error(self, ollama_service):
+        """Test HTTP error handling."""
+        http_error = httpx.HTTPStatusError("Bad Request", request=MagicMock(), response=MagicMock())
+        stub_response = StubAsyncResponse(raise_for_status_exc=http_error)
+        with patch('httpx.AsyncClient', return_value=StubAsyncClient(post_result=stub_response)):
+            with pytest.raises(httpx.HTTPError):
+                await ollama_service.summarize_text("Test text")
+    
+    @pytest.mark.asyncio
+    async def test_check_health_success(self, ollama_service):
+        """Test successful health check."""
+        stub_response = StubAsyncResponse(status_code=200)
+        with patch('httpx.AsyncClient', return_value=StubAsyncClient(get_result=stub_response)):
+            result = await ollama_service.check_health()
+            assert result is True
+    
+    @pytest.mark.asyncio
+    async def test_check_health_failure(self, ollama_service):
+        """Test health check failure."""
+        with patch('httpx.AsyncClient', return_value=StubAsyncClient(get_exc=httpx.HTTPError("Connection failed"))):
+            result = await ollama_service.check_health()
+            assert result is False