Initial deployment to Hugging Face Spaces

.env.example

@@ -0,0 +1,17 @@
+# OpenAI Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Google Gemini Configuration
+GOOGLE_API_KEY=your_google_api_key_here
+
+# Application Configuration
+DEFAULT_MODEL=gpt-4o
+# Available options: gpt-3.5-turbo, gpt-4, gpt-4-turbo, gemini-pro, gemini-1.5-pro
+
+# Chainlit Configuration
+CHAINLIT_HOST=0.0.0.0
+CHAINLIT_PORT=8000
+
+# Development Settings
+DEBUG=False
+LOG_LEVEL=INFO

.gitignore

@@ -0,0 +1,80 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+*.manifest
+*.spec
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Environments
+.env
+.env.*
+!.env.example
+venv/
+.venv/
+env/
+.env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs and editors
+.idea/
+.vscode/
+*.sublime-*
+
+# Chainlit specific
+.chainlit/db/
+.chainlit/
+!.chainlit/config.toml
+
+# OS-specific
+.DS_Store
+Thumbs.db
+
+# uv
+.uv/ 

.vercelignore

@@ -0,0 +1,20 @@
+venv/
+venv/
+ENV/
+.git/
+.idea/
+.vscode/
+*.pyc
+*.pyo
+*.pyd
+tests/
+pytest_cache/
+.coverage
+htmlcov/
+.chainlit/db/
+.chainlit/run.log
+.DS_Store
+Thumbs.db
+.env
+.env.*
+!.env.example

Dockerfile

@@ -0,0 +1,28 @@
+# Use the official Python 3.12 image as requested
+FROM python:3.12
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Create a non-root user for better security
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables for the new user's path
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Copy requirements first to leverage Docker's layer caching
+COPY --chown=user./requirements.txt.
+RUN pip install -r requirements.txt
+
+# Copy the rest of the application code into the container
+COPY --chown=user..
+
+# Expose the port Hugging Face Spaces uses for web apps
+EXPOSE 7860
+
+# The command to run the Chainlit application in production
+# -h (headless) is critical and prevents the server from trying to open a browser
+# --host 0.0.0.0 makes the app accessible within the container's network
+CMD ["chainlit", "run", "src/naked_chat/app.py", "--host", "0.0.0.0", "--port", "7860", "-h"]

README_OLD.md

@@ -0,0 +1,147 @@
+# Naked Insurance - LLM Chat Client POC
+
+This repository contains the Proof of Concept (POC) for a Large Language Model (LLM) powered chat client for internal use at Naked Insurance. The application is built using the Chainlit framework for both the frontend and backend.
+
+## 🎯 Project Overview
+
+This POC demonstrates a modern, production-ready approach to building an LLM-powered chat interface that can integrate with multiple AI providers (OpenAI, Google Gemini) while maintaining a clean, maintainable codebase.
+
+### Key Features
+
+- **Multi-Provider LLM Support**: Seamless integration with OpenAI GPT models (including flagship and reasoning models) and Google Gemini
+- **Latest AI Models**: Support for GPT-4.1, GPT-4o, o3 series reasoning models, and Gemini 2.5 Pro/Flash
+- **Modern Python Architecture**: Uses the `src` layout with proper packaging and dependency management
+- **Production-Ready Foundation**: Comprehensive tooling for linting, testing, and type checking
+- **Chainlit Framework**: Leverages Chainlit for rapid prototyping of chat interfaces
+- **Environment-Based Configuration**: Secure handling of API keys and configuration
+
+## 🏗️ Architecture
+
+The project follows modern Python best practices with a clear separation of concerns:
+
+```
+naked-chat-poc/
+├── .chainlit/              # Chainlit-specific configurations
+├── .github/                # GitHub templates and workflows
+├── public/                 # Static assets (themes, logos, etc.)
+├── src/naked_chat/         # Main application package
+├── tests/                  # Test suite
+├── pyproject.toml          # Project configuration and dependencies
+└── README.md              # This file
+```
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.9 or higher
+- [uv](https://github.com/astral-sh/uv) (recommended) or pip
+
+### Installation
+
+1. **Clone the repository**:
+
+   ```bash
+   git clone https://github.com/naked-insurance/naked-chat-poc.git
+   cd naked-chat-poc
+   ```
+
+2. **Set up the environment**:
+
+   ```bash
+   # Using uv (recommended)
+   uv venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   uv pip install -e ".[dev]"
+
+   # Or using pip
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   pip install -e ".[dev]"
+   ```
+
+3. **Configure environment variables**:
+
+   ```bash
+   cp .env.example .env
+   # Edit .env with your API keys and configuration
+   ```
+
+4. **Run the application**:
+   ```bash
+   chainlit run src/naked_chat/app.py
+   ```
+
+The application will be available at `http://localhost:8000`.
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+Copy `.env.example` to `.env` and configure the following variables:
+
+- `OPENAI_API_KEY`: Your OpenAI API key
+- `GOOGLE_API_KEY`: Your Google Gemini API key
+- `DEFAULT_MODEL`: Default LLM model to use
+
+### Chainlit Configuration
+
+The `.chainlit/config.toml` file contains Chainlit-specific settings for data persistence, file uploads, and UI customization.
+
+## 🧪 Development
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=naked_chat
+```
+
+### Code Quality
+
+```bash
+# Linting and formatting with Ruff
+ruff check .
+ruff format .
+
+# Type checking with mypy
+mypy src/naked_chat
+```
+
+### Development Workflow
+
+1. Create a feature branch: `git checkout -b feature/your-feature-name`
+2. Make your changes
+3. Run tests and quality checks: `pytest && ruff check . && mypy src/naked_chat`
+4. Commit your changes: `git commit -m "Add your feature"`
+5. Push and create a pull request
+
+## 📁 Project Structure Details
+
+- **`src/naked_chat/`**: Main application package following the src layout
+  - `app.py`: Chainlit application entry point
+  - `models/`: LLM integration modules
+  - `utils/`: Utility functions and helpers
+- **`tests/`**: Comprehensive test suite
+  - Unit tests for core functionality
+  - Integration tests for LLM providers
+- **`.chainlit/`**: Chainlit configuration
+  - `config.toml`: Framework settings and customizations
+- **`public/`**: Static assets
+  - `theme.json`: Custom branding and themes
+  - Assets like logos, favicons, etc.
+
+## 🤝 Contributing
+
+This is an internal POC project. Please follow the established code style and ensure all tests pass before submitting changes.
+
+## 📄 License
+
+This project is proprietary to Naked Insurance.
+
+---
+
+**Note**: This is a Proof of Concept intended for internal evaluation and demonstration purposes.

chainlit.md

@@ -0,0 +1,14 @@
+# Welcome to Chainlit! 🚀🤖
+
+Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
+
+## Useful Links 🔗
+
+- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
+- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
+
+We can't wait to see what you create with Chainlit! Happy coding! 💻😊
+
+## Welcome screen
+
+To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

public/theme.json

@@ -0,0 +1,70 @@
+{
+  "custom_fonts": [
+    "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap"
+  ],
+  "variables": {
+    "light": {
+      "--font-sans": "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+      "--font-mono": "source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace",
+      "--background": "0 0% 98%",
+      "--foreground": "0 0% 13%",
+      "--card": "0 0% 100%",
+      "--card-foreground": "0 0% 13%",
+      "--popover": "0 0% 100%",
+      "--popover-foreground": "0 0% 13%",
+      "--primary": "207 90% 54%",
+      "--primary-foreground": "0 0% 100%",
+      "--secondary": "340 97% 43%",
+      "--secondary-foreground": "0 0% 100%",
+      "--muted": "0 0% 96%",
+      "--muted-foreground": "0 0% 46%",
+      "--accent": "0 0% 96%",
+      "--accent-foreground": "0 0% 13%",
+      "--destructive": "0 84% 60%",
+      "--destructive-foreground": "0 0% 98%",
+      "--border": "0 0% 90%",
+      "--input": "0 0% 90%",
+      "--ring": "207 90% 54%",
+      "--radius": "0.75rem",
+      "--sidebar-background": "0 0% 98%",
+      "--sidebar-foreground": "0 0% 46%",
+      "--sidebar-primary": "0 0% 13%",
+      "--sidebar-primary-foreground": "0 0% 98%",
+      "--sidebar-accent": "0 0% 96%",
+      "--sidebar-accent-foreground": "0 0% 13%",
+      "--sidebar-border": "0 0% 91%",
+      "--sidebar-ring": "207 90% 54%"
+    },
+    "dark": {
+      "--font-sans": "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+      "--font-mono": "source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace",
+      "--background": "0 0% 13%",
+      "--foreground": "0 0% 93%",
+      "--card": "0 0% 18%",
+      "--card-foreground": "145, 61%, 55%",
+      "--popover": "0 0% 18%",
+      "--popover-foreground": "145, 61%, 55%",
+      "--primary": "145, 61%, 55%",
+      "--primary-foreground": "0 0% 100%",
+      "--secondary": "340 97% 43%",
+      "--secondary-foreground": "0 0% 100%",
+      "--muted": "0 1% 26%",
+      "--muted-foreground": "0 0% 71%",
+      "--accent": "0 0% 26%",
+      "--accent-foreground": "0 0% 98%",
+      "--destructive": "0 63% 31%",
+      "--destructive-foreground": "0 0% 98%",
+      "--border": "0 1% 26%",
+      "--input": "0 1% 26%",
+      "--ring": "207 90% 54%",
+      "--sidebar-background": "0 0% 9%",
+      "--sidebar-foreground": "0 0% 96%",
+      "--sidebar-primary": "207 90% 54%",
+      "--sidebar-primary-foreground": "0 0% 100%",
+      "--sidebar-accent": "0 0% 13%",
+      "--sidebar-accent-foreground": "0 0% 96%",
+      "--sidebar-border": "0 4% 16%",
+      "--sidebar-ring": "207 90% 54%"
+    }
+  }
+}

pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "naked-chat-poc"
+version = "0.1.0"
+description = "A POC for an LLM-powered chat client for Naked Insurance using Chainlit."
+authors = [
+    { name = "Gustav Klingbiel", email = "gustav.klingbiel@naked.insure" },
+]
+license = { text = "Proprietary" }
+requires-python = ">=3.9"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+# Core runtime dependencies
+dependencies = [
+    "chainlit>=1.0.0",
+    "openai",
+    "google-generativeai",
+    "python-dotenv",
+    "requests",
+]
+
+[project.urls]
+Repository = "https://github.com/naked-insurance/naked-chat-poc"
+
+[project.optional-dependencies]
+# Dependencies for local development, testing, and linting
+dev = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "ruff",
+    "mypy",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["naked_chat"]
+package-dir = {"" = "src"}
+
+# Configuration for the Ruff linter and formatter
+# Ruff is an extremely fast, all-in-one tool that replaces flake8, isort, and black.
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+ignore = ["E501"] # Handled by the formatter
+
+[tool.ruff.format]
+quote-style = "double"
+
+# Configuration for the mypy static type checker
+[tool.mypy]
+strict = true
+ignore_missing_imports = true 

requirements.txt

@@ -0,0 +1,5 @@
+chainlit>=1.0.0
+openai
+google-generativeai
+python-dotenv
+requests

src/naked_chat/__init__.py

@@ -0,0 +1,9 @@
+"""
+Naked Insurance LLM Chat Client POC
+
+A Chainlit-powered chat interface for integrating with multiple LLM providers.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Gustav Klingbiel"
+__email__ = "gustav.klingbiel@naked.insure"

src/naked_chat/app.py

@@ -0,0 +1,252 @@
+"""
+Main Chainlit application for the Naked Insurance LLM Chat POC.
+
+This module serves as the entry point for the Chainlit application and handles
+the chat interface, LLM provider integration, and message processing.
+"""
+
+import os
+from typing import Optional, Dict
+
+import chainlit as cl
+import google.generativeai as genai
+from dotenv import load_dotenv
+from openai import AsyncOpenAI
+
+# Load environment variables
+load_dotenv()
+
+# Configuration
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "gpt-4o")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+# Initialize clients
+openai_client = AsyncOpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
+if GOOGLE_API_KEY:
+    genai.configure(api_key=GOOGLE_API_KEY)
+
+
+@cl.oauth_callback
+def oauth_callback(
+    provider_id: str,
+    token: str,
+    raw_user_data: Dict[str, str],
+    default_user: cl.User,
+) -> Optional[cl.User]:
+    """
+    This function is called after a user successfully authenticates with a provider.
+    It's responsible for validating the user and granting access.
+    """
+
+    if provider_id == "google":
+        # Allow users from both naked.insure and klingbiel.org domains
+        allowed_domains = {"naked.insure", "klingbiel.org"}
+        user_domain = raw_user_data.get("hd")
+
+        if user_domain in allowed_domains:
+            return default_user
+        else:
+            return None
+
+    # If for some reason another provider was configured, deny access.
+    return None
+
+
+@cl.on_chat_start
+async def start():
+    """
+    Initialize the chat session and set up the initial state.
+    """
+    settings = await cl.ChatSettings(
+        [
+            cl.input_widget.Select(
+                id="Model",
+                label="Choose LLM Model",
+                values=[
+                    # OpenAI Flagship Models
+                    "gpt-4.1",
+                    "gpt-4o",
+                    # OpenAI Reasoning Models
+                    "o4-mini",
+                    "o3",
+                    "o3-pro",
+                    "o3-mini",
+                    # Legacy OpenAI Models
+                    "gpt-3.5-turbo",
+                    "gpt-4",
+                    "gpt-4-turbo",
+                    # Google Gemini Models
+                    "gemini-2.5-pro",
+                    "gemini-2.5-flash",
+                    "gemini-pro",
+                ],
+                initial_index=1,  # Default to gpt-4o
+            ),
+            cl.input_widget.Slider(
+                id="Temperature",
+                label="Temperature",
+                initial=0.7,
+                min=0,
+                max=2,
+                step=0.1,
+            ),
+            cl.input_widget.Slider(
+                id="MaxTokens",
+                label="Max Output Tokens",
+                initial=500,
+                min=50,
+                max=2000,
+                step=50,
+            ),
+        ]
+    ).send()
+
+    # Store initial settings in user session
+    cl.user_session.set("settings", settings)
+    cl.user_session.set("model", DEFAULT_MODEL)
+    cl.user_session.set("temperature", 0.7)
+    cl.user_session.set("max_tokens", 500)
+
+    # Welcome message
+    await cl.Message(
+        content="""# Welcome to Naked Insurance Chat POC! 🚀
+
+You can adjust the model and parameters using the settings panel. Let's get started!
+        """,
+        author="Assistant",
+    ).send()
+
+
+@cl.on_settings_update
+async def setup_agent(settings):
+    """
+    Handle settings updates from the user interface.
+    """
+    print(f"Settings updated: {settings}")
+    cl.user_session.set("model", settings["Model"])
+    cl.user_session.set("temperature", settings["Temperature"])
+    cl.user_session.set("max_tokens", settings["MaxTokens"])
+
+
+async def call_openai_model(
+    model: str, messages: list, temperature: float, max_tokens: int
+) -> str:
+    """
+    Call OpenAI API with the specified parameters.
+    """
+    if not openai_client:
+        raise ValueError("OpenAI API key not configured")
+
+    response = await openai_client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+
+    return response.choices[0].message.content
+
+
+async def call_gemini_model(
+    model: str, messages: list, temperature: float, max_tokens: int
+) -> str:
+    """
+    Call Google Gemini API with the specified parameters.
+    """
+    if not GOOGLE_API_KEY:
+        raise ValueError("Google API key not configured")
+
+    # Convert messages to Gemini format
+    prompt = "\n".join([f"{msg['role']}: {msg['content']}" for msg in messages])
+
+    # Map new model names to actual API names
+    model_mapping = {
+        "gemini-2.5-pro": "gemini-2.5-pro",
+        "gemini-2.5-flash": "gemini-2.5-flash",
+        "gemini-pro": "gemini-pro",
+    }
+
+    api_model = model_mapping.get(model, model)
+    model_instance = genai.GenerativeModel(api_model)
+    response = await model_instance.generate_content_async(
+        prompt,
+        generation_config=genai.types.GenerationConfig(
+            temperature=temperature,
+            max_output_tokens=max_tokens,
+        ),
+    )
+
+    return response.text
+
+
+@cl.on_message
+async def main(message: cl.Message):
+    """
+    Handle incoming messages and generate responses using the selected LLM.
+    """
+    # Get user settings
+    model = cl.user_session.get("model")
+    temperature = cl.user_session.get("temperature")
+    max_tokens = cl.user_session.get("max_tokens")
+
+    # Get message history
+    message_history = cl.user_session.get("message_history", [])
+
+    # Add current message to history
+    message_history.append({"role": "user", "content": message.content})
+
+    # Keep only last 10 messages to manage context length
+    if len(message_history) > 10:
+        message_history = message_history[-10:]
+
+    # Store updated history
+    cl.user_session.set("message_history", message_history)
+
+    try:
+        # Show loading indicator
+        msg = cl.Message(content="")
+        await msg.send()
+
+        # Route to appropriate model
+        if model.startswith("gpt") or model.startswith("o"):
+            response_content = await call_openai_model(
+                model=model,
+                messages=message_history,
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+        elif model.startswith("gemini"):
+            response_content = await call_gemini_model(
+                model=model,
+                messages=message_history,
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+        else:
+            response_content = f"Model '{model}' is not supported yet."
+
+        # Update message with response
+        msg.content = response_content
+        await msg.update()
+
+        # Add assistant response to history
+        message_history.append({"role": "assistant", "content": response_content})
+        cl.user_session.set("message_history", message_history)
+
+    except Exception as e:
+        error_msg = f"Error generating response: {str(e)}"
+        print(f"Error: {error_msg}")
+
+        msg.content = (
+            f"❌ **Error**: {error_msg}\n\nPlease check your API keys and try again."
+        )
+        await msg.update()
+
+
+if __name__ == "__main__":
+    # This allows running the app directly with: python src/naked_chat/app.py
+    import subprocess
+    import sys
+
+    subprocess.run([sys.executable, "-m", "chainlit", "run", __file__])

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package for naked-chat-poc

tests/test_app.py

@@ -0,0 +1,111 @@
+"""
+Tests for the main Chainlit application.
+"""
+
+import os
+import sys
+from unittest.mock import patch
+
+import pytest
+
+# Add the src directory to the path so we can import our modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from naked_chat import __version__
+
+
+def test_version():
+    """Test that the version is properly defined."""
+    assert __version__ == "0.1.0"
+
+
+def test_environment_variables():
+    """Test that environment variables are properly handled."""
+    # Test with missing environment variables
+    with patch.dict(os.environ, {}, clear=True):
+        from naked_chat.app import DEFAULT_MODEL, GOOGLE_API_KEY, OPENAI_API_KEY
+
+        assert DEFAULT_MODEL == "gpt-4o"
+        assert OPENAI_API_KEY is None
+        assert GOOGLE_API_KEY is None
+
+
+def test_openai_model_validation():
+    """Test OpenAI model validation."""
+    from naked_chat.app import call_openai_model
+
+    # Test with no API key configured
+    with patch("naked_chat.app.openai_client", None):
+        with pytest.raises(ValueError, match="OpenAI API key not configured"):
+            import asyncio
+
+            asyncio.run(call_openai_model("gpt-3.5-turbo", [], 0.7, 100))
+
+
+def test_gemini_model_validation():
+    """Test Gemini model validation."""
+    from naked_chat.app import call_gemini_model
+
+    # Test with no API key configured
+    with patch("naked_chat.app.GOOGLE_API_KEY", None):
+        with pytest.raises(ValueError, match="Google API key not configured"):
+            import asyncio
+
+            asyncio.run(call_gemini_model("gemini-pro", [], 0.7, 100))
+
+
+class TestAppConstants:
+    """Test class for application constants and configuration."""
+
+    def test_default_model_is_valid(self):
+        """Test that the default model is a valid option."""
+        from naked_chat.app import DEFAULT_MODEL
+
+        valid_models = [
+            # OpenAI Flagship Models
+            "gpt-4.1",
+            "gpt-4o",
+            # OpenAI Reasoning Models
+            "o4-mini",
+            "o3",
+            "o3-pro",
+            "o3-mini",
+            # Google Gemini Models
+            "gemini-2.5-pro",
+            "gemini-2.5-flash",
+        ]
+        assert DEFAULT_MODEL in valid_models
+
+    def test_import_structure(self):
+        """Test that all required modules can be imported."""
+        try:
+            import naked_chat
+            import naked_chat.app
+
+            assert True
+        except ImportError as e:
+            pytest.fail(f"Import failed: {e}")
+
+
+# Example of integration test structure (would need mocking for actual API calls)
+class TestChatIntegration:
+    """Integration tests for chat functionality."""
+
+    @pytest.mark.asyncio
+    async def test_message_history_management(self):
+        """Test that message history is properly managed."""
+        # This would be a more complex test with actual Chainlit session mocking
+        # For now, just test the concept
+        message_history = []
+
+        # Simulate adding messages
+        for i in range(15):
+            message_history.append({"role": "user", "content": f"Message {i}"})
+
+        # Test that history is truncated to last 10 messages
+        if len(message_history) > 10:
+            message_history = message_history[-10:]
+
+        assert len(message_history) == 10
+        assert message_history[0]["content"] == "Message 5"
+        assert message_history[-1]["content"] == "Message 14"

vercel.json

@@ -0,0 +1,14 @@
+{
+  "builds": [
+    {
+      "src": "src/naked_chat/app.py",
+      "use": "@vercel/python"
+    }
+  ],
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "src/naked_chat/app.py"
+    }
+  ]
+}