Initial backend deployment - Hono proxy + ColPali embedding API

.env.example

@@ -0,0 +1,9 @@
+# Vespa Configuration
+VESPA_ENDPOINT=https://your-vespa-endpoint.vespa-cloud.com
+VESPA_CERT_PATH=/home/user/.vespa/il-infra.colpali-server.default
+
+# CORS Configuration
+CORS_ORIGIN=*
+
+# API Configuration
+EMBEDDING_API_URL=http://localhost:8001

.gitignore

@@ -0,0 +1,5 @@
+*.log
+node_modules/
+__pycache__/
+.env.local
+.DS_Store

Dockerfile

@@ -0,0 +1,70 @@
+FROM node:20-slim
+
+# Install Python and system dependencies
+RUN apt-get update && apt-get install -y \
+    python3.11 \
+    python3-pip \
+    python3.11-venv \
+    git \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user (required by HF Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set working directory
+WORKDIR $HOME/app
+
+# Copy backend files only
+COPY --chown=user embedding_api.py $HOME/app/
+COPY --chown=user requirements_embedding.txt $HOME/app/
+COPY --chown=user hono-proxy $HOME/app/hono-proxy
+
+# Create Python virtual environment
+RUN python3.11 -m venv $HOME/venv
+ENV PATH="$HOME/venv/bin:$PATH"
+
+# Install Python dependencies for embedding API
+RUN pip install --upgrade pip
+RUN pip install -r requirements_embedding.txt
+
+# Install pnpm and Node dependencies for Hono proxy
+RUN npm install -g pnpm
+WORKDIR $HOME/app/hono-proxy
+RUN pnpm install
+
+# Copy Vespa certificates (these need to be included in the repo)
+RUN mkdir -p $HOME/.vespa/il-infra.colpali-server.default
+COPY --chown=user vespa-certs/* $HOME/.vespa/il-infra.colpali-server.default/ || true
+
+# Create startup script for backend services only
+WORKDIR $HOME/app
+RUN cat > start-backend.sh << 'EOF'
+#!/bin/bash
+
+# Start embedding API on port 8001
+echo "Starting ColPali embedding API on port 8001..."
+python embedding_api.py &
+EMBED_PID=$!
+
+# Wait for embedding API to be ready
+sleep 10
+
+# Start Hono proxy on HF Spaces port 7860
+echo "Starting Hono proxy on port 7860..."
+cd hono-proxy && PORT=7860 CORS_ORIGIN="*" EMBEDDING_API_URL="http://localhost:8001" npx tsx src/index.ts
+
+# If Hono exits, kill embedding service
+kill $EMBED_PID
+EOF
+
+RUN chmod +x start-backend.sh
+
+# Expose HF Spaces port (Hono proxy will run on this)
+EXPOSE 7860
+
+# Run the startup script
+CMD ["./start-backend.sh"]

README.md

@@ -0,0 +1,47 @@
+---
+title: ColPali Backend API
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: apache-2.0
+---
+
+# ColPali Backend API
+
+This Space provides the backend services for ColPali visual document retrieval:
+- **Hono Proxy API** on port 7860
+- **ColPali Embedding Service** on port 8001 (internal)
+
+## API Endpoints
+
+### Query Endpoint
+```
+POST /api/query
+Content-Type: application/json
+
+{
+  "query": "your search query",
+  "limit": 10
+}
+```
+
+### Health Check
+```
+GET /api/health
+```
+
+## Usage
+
+Configure your frontend to point to:
+```
+https://[your-username]-[space-name].hf.space
+```
+
+## Environment Variables
+
+Set these in your HF Space settings:
+- `VESPA_ENDPOINT`: Your Vespa cluster endpoint
+- `VESPA_CERT_PATH`: Path to Vespa certificates
+- `CORS_ORIGIN`: Allowed origins for CORS (default: *)

embedding_api.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+ColPali Embedding API for generating query embeddings
+"""
+
+import os
+import logging
+import numpy as np
+from pathlib import Path
+from typing import List, Dict
+from fastapi import FastAPI, Query, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import torch
+from PIL import Image
+import uvicorn
+
+from colpali_engine.models import ColPali, ColPaliProcessor
+from colpali_engine.utils.torch_utils import get_torch_device
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI
+app = FastAPI(title="ColPali Embedding API")
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3025", "http://localhost:4000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global model variables
+model = None
+processor = None
+device = None
+
+MAX_QUERY_TERMS = 64
+
+def load_model():
+    """Load ColPali model and processor"""
+    global model, processor, device
+    
+    if model is None:
+        logger.info("Loading ColPali model...")
+        device = get_torch_device("auto")
+        logger.info(f"Using device: {device}")
+        
+        try:
+            model_name = "vidore/colpali-v1.2"
+            model = ColPali.from_pretrained(
+                model_name,
+                torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+                device_map=device
+            ).eval()
+            processor = ColPaliProcessor.from_pretrained(model_name)
+            logger.info("ColPali model loaded successfully")
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            # Try alternative model
+            model_name = "vidore/colpaligemma-3b-pt-448-base"
+            model = ColPali.from_pretrained(
+                model_name,
+                torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+                device_map=device
+            ).eval()
+            processor = ColPaliProcessor.from_pretrained(model_name)
+            logger.info(f"Loaded alternative model: {model_name}")
+    
+    return model, processor
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "colpali-embedding-api"}
+
+
+@app.get("/embed_query")
+async def embed_query(
+    query: str = Query(..., description="Text query to embed")
+):
+    """Generate ColPali embeddings for a text query"""
+    try:
+        model, processor = load_model()
+        
+        # Create a dummy image for text-only queries
+        # ColPali expects image inputs, so we use a white image
+        dummy_image = Image.new('RGB', (448, 448), color='white')
+        
+        # Process query with dummy image
+        inputs = processor(
+            images=[dummy_image],
+            text=[query],
+            return_tensors="pt",
+            padding=True
+        ).to(device)
+        
+        # Generate embeddings
+        with torch.no_grad():
+            embeddings = model(**inputs)  # Direct output, not .last_hidden_state
+        
+        # Process embeddings for Vespa format
+        # Extract query embeddings (text tokens)
+        query_embeddings = embeddings[0]  # First item in batch
+        
+        # Convert to list format expected by Vespa
+        float_query_embedding = {}
+        binary_query_embeddings = {}
+        
+        for idx in range(min(query_embeddings.shape[0], MAX_QUERY_TERMS)):
+            embedding_vector = query_embeddings[idx].cpu().numpy().tolist()
+            float_query_embedding[str(idx)] = embedding_vector
+            
+            # Create binary version
+            binary_vector = (
+                np.packbits(np.where(np.array(embedding_vector) > 0, 1, 0))
+                .astype(np.int8)
+                .tolist()
+            )
+            binary_query_embeddings[str(idx)] = binary_vector
+        
+        return {
+            "query": query,
+            "embeddings": {
+                "float": float_query_embedding,
+                "binary": binary_query_embeddings
+            },
+            "num_tokens": len(float_query_embedding)
+        }
+        
+    except Exception as e:
+        logger.error(f"Embedding error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/embed_query_simple")
+async def embed_query_simple(
+    query: str = Query(..., description="Text query to embed")
+):
+    """Generate simplified embeddings for text query (for testing)"""
+    try:
+        # For testing, return mock embeddings
+        # In production, this would use the actual ColPali model
+        mock_embedding = [0.1] * 128  # 128-dimensional embedding
+        
+        return {
+            "query": query,
+            "embedding": mock_embedding,
+            "model": "colpali-v1.2"
+        }
+        
+    except Exception as e:
+        logger.error(f"Embedding error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("EMBEDDING_PORT", "7861"))
+    logger.info(f"Starting ColPali Embedding API on port {port}")
+    # Pre-load model
+    load_model()
+    uvicorn.run(app, host="0.0.0.0", port=port)

hono-proxy/.env.backend-hf

@@ -0,0 +1,23 @@
+# Hugging Face Backend Deployment Configuration
+# Jul 24 - Backend services only (Hono + ColPali)
+
+# Server Configuration
+PORT=7860
+NODE_ENV=production
+
+# CORS - Allow all origins for external frontend access
+CORS_ORIGIN=*
+
+# Vespa Configuration
+VESPA_ENDPOINT=https://il-infra.colpali-server.default.vespa-cloud.com
+VESPA_CERT_PATH=/home/user/.vespa/il-infra.colpali-server.default
+
+# Internal Services
+EMBEDDING_API_URL=http://localhost:8001
+
+# API Configuration
+MAX_QUERY_TERMS=64
+QUERY_TIMEOUT_MS=30000
+
+# Logging
+LOG_LEVEL=info

hono-proxy/.env.example

@@ -0,0 +1,22 @@
+# Server Configuration
+PORT=4000
+NODE_ENV=development
+
+# Backend Configuration
+BACKEND_URL=http://localhost:7860
+
+# CORS Configuration
+CORS_ORIGIN=http://localhost:3000
+
+# Cache Configuration
+ENABLE_CACHE=true
+CACHE_TTL=300  # 5 minutes
+
+# Rate Limiting
+RATE_LIMIT_WINDOW=60000  # 1 minute in ms
+RATE_LIMIT_MAX=100
+
+# Vespa Configuration (if direct access needed)
+# VESPA_APP_URL=https://your-app.vespa-app.cloud
+# VESPA_CERT_PATH=/path/to/cert.pem
+# VESPA_KEY_PATH=/path/to/key.pem

hono-proxy/.env.hf

@@ -0,0 +1,22 @@
+# Server Configuration
+PORT=4025
+NODE_ENV=production
+
+# Backend Configuration - Direct to Vespa
+BACKEND_URL=https://f5acf536.ed2ceb09.z.vespa-app.cloud
+
+# CORS Configuration - Allow all origins in HF Spaces
+CORS_ORIGIN=*
+
+# Cache Configuration
+ENABLE_CACHE=true
+CACHE_TTL=300
+
+# Rate Limiting
+RATE_LIMIT_WINDOW=60000
+RATE_LIMIT_MAX=100
+
+# Vespa Configuration
+VESPA_APP_URL=https://f5acf536.ed2ceb09.z.vespa-app.cloud
+VESPA_CERT_PATH=/home/user/.vespa/il-infra.colpali-server.default/data-plane-public-cert.pem
+VESPA_KEY_PATH=/home/user/.vespa/il-infra.colpali-server.default/data-plane-private-key.pem

hono-proxy/.gitignore

@@ -0,0 +1,13 @@
+node_modules/
+dist/
+.env
+.env.local
+.DS_Store
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+coverage/
+.nyc_output/
+.vscode/
+.idea/

hono-proxy/Dockerfile

@@ -0,0 +1,56 @@
+# Build stage
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+COPY tsconfig.json ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy source code
+COPY src ./src
+
+# Build the application
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Install dumb-init for proper signal handling
+RUN apk add --no-cache dumb-init
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+# Copy package files
+COPY package*.json ./
+
+# Install production dependencies only
+RUN npm ci --only=production && \
+    npm cache clean --force
+
+# Copy built application from builder
+COPY --from=builder /app/dist ./dist
+
+# Change ownership
+RUN chown -R nodejs:nodejs /app
+
+# Switch to non-root user
+USER nodejs
+
+# Expose port
+EXPOSE 4000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD node -e "require('http').get('http://localhost:4000/health/live', (r) => r.statusCode === 200 ? process.exit(0) : process.exit(1))"
+
+# Use dumb-init to handle signals properly
+ENTRYPOINT ["dumb-init", "--"]
+CMD ["node", "dist/index.js"]

hono-proxy/README-NEXTJS-COMPATIBILITY.md

@@ -0,0 +1,127 @@
+# Hono Proxy - Next.js Compatibility Guide
+
+This Hono proxy server is designed to be a **drop-in replacement** for the Next.js API routes, providing 100% compatibility with the existing frontend.
+
+## Endpoint Mapping
+
+The Hono proxy implements all endpoints exactly as they exist in the Next.js implementation:
+
+| Next.js API Route | Backend Endpoint | Method | Description |
+|-------------------|------------------|---------|-------------|
+| `/api/colpali-search` | `/fetch_results` | GET | Search with ColPali ranking |
+| `/api/full-image` | `/full_image` | GET | Get full resolution image |
+| `/api/query-suggestions` | `/suggestions` | GET | Autocomplete suggestions |
+| `/api/similarity-maps` | `/get_sim_map` | GET | Generate similarity visualization |
+| `/api/visual-rag-chat` | `/get-message` | GET (SSE) | Stream chat responses |
+
+## Parameter Compatibility
+
+All query parameters are preserved exactly as in Next.js:
+
+### Search
+```
+GET /api/colpali-search?query=annual+report&ranking=hybrid
+```
+
+### Full Image
+```
+GET /api/full-image?docId=abc123
+```
+
+### Suggestions
+```
+GET /api/query-suggestions?query=ann
+```
+
+### Similarity Maps
+```
+GET /api/similarity-maps?queryId=123&idx=0&token=report&tokenIdx=2
+```
+
+### Visual RAG Chat (SSE)
+```
+GET /api/visual-rag-chat?queryId=123&query=What+is+revenue&docIds=abc,def,ghi
+```
+
+## Frontend Integration
+
+To use the Hono proxy with your Next.js frontend:
+
+1. Update your environment variable:
+   ```env
+   # .env.local
+   NEXT_PUBLIC_API_URL=http://localhost:4000
+   ```
+
+2. Update your API calls (if using relative paths):
+   ```typescript
+   // If currently using relative paths like:
+   const response = await fetch('/api/colpali-search?query=...');
+   
+   // Change to:
+   const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/colpali-search?query=...`);
+   ```
+
+3. Or use a base URL configuration:
+   ```typescript
+   // utils/api.ts
+   export const API_BASE = process.env.NEXT_PUBLIC_API_URL || '';
+   
+   // In components:
+   const response = await fetch(`${API_BASE}/api/colpali-search?query=...`);
+   ```
+
+## Response Format
+
+All responses are identical to what Next.js returns:
+
+- Search results include the same Vespa response structure
+- Full images return `{ base64_image: "..." }`
+- Suggestions return `{ suggestions: [...] }`
+- Similarity maps return HTML content
+- SSE chat streams the same event format
+
+## Additional Features
+
+While maintaining 100% compatibility, the Hono proxy adds:
+
+- **Caching**: Search results and images are cached
+- **Rate Limiting**: Prevents backend overload
+- **Health Checks**: Monitor backend availability
+- **Request IDs**: Track requests across systems
+- **Performance**: Faster response times with caching
+
+## Migration Path
+
+1. **No Frontend Changes Required**: The Hono proxy mimics Next.js API routes exactly
+2. **Gradual Migration**: Can run both Next.js and Hono simultaneously on different ports
+3. **Environment-based**: Use environment variables to switch between implementations
+
+## Testing Compatibility
+
+Test script to verify all endpoints work:
+
+```bash
+# Search
+curl "http://localhost:4000/api/colpali-search?query=annual+report&ranking=hybrid"
+
+# Full Image  
+curl "http://localhost:4000/api/full-image?docId=abc123"
+
+# Suggestions
+curl "http://localhost:4000/api/query-suggestions?query=ann"
+
+# Similarity Map
+curl "http://localhost:4000/api/similarity-maps?queryId=123&idx=0&token=report&tokenIdx=2"
+
+# Visual RAG Chat (SSE)
+curl -N "http://localhost:4000/api/visual-rag-chat?queryId=123&query=What+is+revenue&docIds=abc,def"
+```
+
+## Benefits Over Next.js API Routes
+
+1. **Independent Scaling**: Scale API separately from frontend
+2. **Better Performance**: Dedicated API server with caching
+3. **Deployment Flexibility**: Deploy anywhere (Docker, K8s, serverless)
+4. **Monitoring**: Built-in health checks and metrics
+5. **Security**: Rate limiting and request validation

hono-proxy/README.md

@@ -0,0 +1,207 @@
+# ColPali Hono Proxy Server
+
+A high-performance proxy server built with Hono that sits between your Next.js frontend and the ColPali/Vespa backend. This proxy handles caching, rate limiting, CORS, and provides a clean API interface.
+
+## Features
+
+- **Image Retrieval**: Serves base64 images from Vespa as actual image files with proper caching
+- **Search Proxy**: Forwards search requests with result caching
+- **Chat SSE Proxy**: Handles Server-Sent Events for streaming chat responses
+- **Rate Limiting**: Protects backend from overload
+- **Caching**: In-memory cache for search results and images
+- **Health Checks**: Kubernetes-ready health endpoints
+- **CORS Handling**: Configurable CORS for frontend integration
+- **Request Logging**: Detailed request/response logging with request IDs
+
+## Architecture
+
+```
+Next.js App (3000) → Hono Proxy (4000) → ColPali Backend (7860)
+                                      ↘ Vespa Cloud
+```
+
+## API Endpoints
+
+### Search
+- `POST /api/search` - Search documents
+  ```json
+  {
+    "query": "annual report 2023",
+    "limit": 10,
+    "ranking": "hybrid"
+  }
+  ```
+
+### Image Retrieval
+- `GET /api/search/image/:docId/thumbnail` - Get thumbnail image
+- `GET /api/search/image/:docId/full` - Get full-size image
+
+### Chat
+- `POST /api/chat` - Stream chat responses (SSE)
+  ```json
+  {
+    "messages": [{"role": "user", "content": "Tell me about..."}],
+    "context": []
+  }
+  ```
+
+### Similarity Map
+- `POST /api/search/similarity-map` - Generate similarity visualization
+
+### Health
+- `GET /health` - Detailed health status
+- `GET /health/live` - Liveness probe
+- `GET /health/ready` - Readiness probe
+
+## Setup
+
+### Development
+
+1. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+2. Copy environment variables:
+   ```bash
+   cp .env.example .env
+   ```
+
+3. Update `.env` with your configuration
+
+4. Run in development mode:
+   ```bash
+   npm run dev
+   ```
+
+### Production
+
+1. Build:
+   ```bash
+   npm run build
+   ```
+
+2. Run:
+   ```bash
+   npm start
+   ```
+
+### Docker
+
+Build and run with Docker:
+```bash
+docker build -t colpali-hono-proxy .
+docker run -p 4000:4000 --env-file .env colpali-hono-proxy
+```
+
+Or use docker-compose:
+```bash
+docker-compose up
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `PORT` | Server port | 4000 |
+| `BACKEND_URL` | ColPali backend URL | http://localhost:7860 |
+| `CORS_ORIGIN` | Allowed CORS origin | http://localhost:3000 |
+| `ENABLE_CACHE` | Enable caching | true |
+| `CACHE_TTL` | Cache TTL in seconds | 300 |
+| `RATE_LIMIT_WINDOW` | Rate limit window (ms) | 60000 |
+| `RATE_LIMIT_MAX` | Max requests per window | 100 |
+
+## Integration with Next.js
+
+Update your Next.js app to use the proxy:
+
+```typescript
+// .env.local
+NEXT_PUBLIC_API_URL=http://localhost:4000/api
+
+// API calls
+const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/search`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ query, limit })
+});
+```
+
+## Caching Strategy
+
+- **Search Results**: Cached for 5 minutes (configurable)
+- **Images**: Cached for 24 hours
+- **Cache Keys**: Based on query parameters
+- **Cache Headers**: `X-Cache: HIT/MISS`
+
+## Rate Limiting
+
+- Default: 100 requests per minute per IP
+- Headers included:
+  - `X-RateLimit-Limit`
+  - `X-RateLimit-Remaining`
+  - `X-RateLimit-Reset`
+
+## Monitoring
+
+The proxy includes:
+- Request logging with correlation IDs
+- Performance timing
+- Error tracking
+- Health endpoints for monitoring
+
+## Deployment Options
+
+### Railway/Fly.io
+```toml
+# fly.toml
+app = "colpali-proxy"
+primary_region = "ord"
+
+[http_service]
+  internal_port = 4000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+```
+
+### Kubernetes
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: colpali-proxy
+spec:
+  replicas: 3
+  template:
+    spec:
+      containers:
+      - name: proxy
+        image: colpali-proxy:latest
+        ports:
+        - containerPort: 4000
+        livenessProbe:
+          httpGet:
+            path: /health/live
+            port: 4000
+        readinessProbe:
+          httpGet:
+            path: /health/ready
+            port: 4000
+```
+
+## Performance
+
+- Built with Hono for maximum performance
+- Efficient streaming for SSE
+- Connection pooling for backend requests
+- In-memory caching reduces backend load
+- Brotli/gzip compression enabled
+
+## Security
+
+- Rate limiting prevents abuse
+- Secure headers enabled
+- CORS properly configured
+- Request ID tracking
+- No sensitive data logging

hono-proxy/client-example.ts

@@ -0,0 +1,156 @@
+/**
+ * Example client for integrating with the Hono proxy from Next.js
+ * Place this in your Next.js app at: lib/api-client.ts
+ */
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4000/api';
+
+export interface SearchResult {
+  root: {
+    children: Array<{
+      id: string;
+      relevance: number;
+      fields: {
+        id: string;
+        title: string;
+        page_number: number;
+        text: string;
+        image: string; // base64
+        image_url: string; // Added by proxy
+        full_image_url: string; // Added by proxy
+      };
+    }>;
+  };
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+class ColPaliClient {
+  private async fetchWithTimeout(url: string, options: RequestInit, timeout = 30000) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeout);
+    
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+      });
+      return response;
+    } finally {
+      clearTimeout(id);
+    }
+  }
+
+  async search(query: string, limit = 10): Promise<SearchResult> {
+    const response = await this.fetchWithTimeout(`${API_URL}/search`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, limit }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Search failed: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async* chat(messages: ChatMessage[], context: string[] = []) {
+    const response = await fetch(`${API_URL}/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ messages, context }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Chat failed: ${response.statusText}`);
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error('No response body');
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') return;
+          
+          try {
+            const parsed = JSON.parse(data);
+            yield parsed;
+          } catch (e) {
+            console.error('Failed to parse SSE data:', e);
+          }
+        }
+      }
+    }
+  }
+
+  async getSimilarityMap(docId: string, query: string) {
+    const response = await this.fetchWithTimeout(`${API_URL}/search/similarity-map`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ docId, query }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Similarity map failed: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  getImageUrl(docId: string, type: 'thumbnail' | 'full' = 'thumbnail'): string {
+    return `${API_URL}/search/image/${docId}/${type}`;
+  }
+
+  async checkHealth() {
+    const response = await this.fetchWithTimeout(`${API_URL.replace('/api', '')}/health`, {
+      method: 'GET',
+    }, 5000);
+
+    return response.json();
+  }
+}
+
+// Export singleton instance
+export const colpaliClient = new ColPaliClient();
+
+// Usage examples:
+/*
+// In your Next.js component or API route:
+
+// Search
+const results = await colpaliClient.search('annual report 2023', 20);
+
+// Display images directly from proxy URLs
+results.root.children.forEach(hit => {
+  const imageUrl = hit.fields.image_url; // Proxy URL for thumbnail
+  const fullImageUrl = hit.fields.full_image_url; // Proxy URL for full image
+});
+
+// Chat with streaming
+const messages = [{ role: 'user', content: 'What is the revenue?' }];
+for await (const chunk of colpaliClient.chat(messages)) {
+  console.log(chunk);
+}
+
+// Get image URL for direct use in <img> tags
+const imageUrl = colpaliClient.getImageUrl('doc123', 'thumbnail');
+
+// Check system health
+const health = await colpaliClient.checkHealth();
+*/

hono-proxy/colpali-response.json

@@ -0,0 +1 @@
+{"error":"Search failed","message":"response.json is not a function"}

hono-proxy/docker-compose.yml

@@ -0,0 +1,29 @@
+version: '3.8'
+
+services:
+  hono-proxy:
+    build: .
+    ports:
+      - "4000:4000"
+    environment:
+      - NODE_ENV=production
+      - PORT=4000
+      - BACKEND_URL=http://backend:7860  # Adjust based on your backend service name
+      - CORS_ORIGIN=http://localhost:3000
+      - ENABLE_CACHE=true
+      - CACHE_TTL=300
+      - RATE_LIMIT_WINDOW=60000
+      - RATE_LIMIT_MAX=100
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:4000/health/live"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+      start_period: 10s
+    restart: unless-stopped
+    networks:
+      - colpali-network
+
+networks:
+  colpali-network:
+    driver: bridge

hono-proxy/ecosystem.config.js

@@ -0,0 +1,23 @@
+module.exports = {
+  apps: [{
+    name: 'colpali-hono-proxy',
+    script: './dist/index.js',
+    instances: 'max',
+    exec_mode: 'cluster',
+    env: {
+      NODE_ENV: 'production',
+      PORT: 4000
+    },
+    error_file: './logs/error.log',
+    out_file: './logs/out.log',
+    log_file: './logs/combined.log',
+    time: true,
+    max_memory_restart: '1G',
+    autorestart: true,
+    watch: false,
+    max_restarts: 10,
+    min_uptime: '10s',
+    listen_timeout: 3000,
+    kill_timeout: 5000,
+  }]
+};

hono-proxy/package-lock.json

@@ -0,0 +1,751 @@
+{
+  "name": "colpali-hono-proxy",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "colpali-hono-proxy",
+      "version": "1.0.0",
+      "dependencies": {
+        "@hono/node-server": "^1.8.0",
+        "@types/uuid": "^10.0.0",
+        "dotenv": "^16.4.1",
+        "hono": "^4.0.0",
+        "node-fetch": "^3.3.2",
+        "uuid": "^9.0.1",
+        "zod": "^3.22.4"
+      },
+      "devDependencies": {
+        "@types/node": "^20.11.5",
+        "tsx": "^4.7.0",
+        "typescript": "^5.3.3"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.8.tgz",
+      "integrity": "sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.8.tgz",
+      "integrity": "sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.8.tgz",
+      "integrity": "sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.8.tgz",
+      "integrity": "sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.8.tgz",
+      "integrity": "sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.8.tgz",
+      "integrity": "sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.8.tgz",
+      "integrity": "sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.8.tgz",
+      "integrity": "sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.8.tgz",
+      "integrity": "sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.8.tgz",
+      "integrity": "sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.8.tgz",
+      "integrity": "sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.8.tgz",
+      "integrity": "sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.8.tgz",
+      "integrity": "sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.8.tgz",
+      "integrity": "sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.8.tgz",
+      "integrity": "sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.8.tgz",
+      "integrity": "sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.8.tgz",
+      "integrity": "sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.8.tgz",
+      "integrity": "sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.8.tgz",
+      "integrity": "sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.8.tgz",
+      "integrity": "sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.8.tgz",
+      "integrity": "sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.8.tgz",
+      "integrity": "sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.8.tgz",
+      "integrity": "sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@hono/node-server": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.17.1.tgz",
+      "integrity": "sha512-SY79W/C+2b1MyAzmIcV32Q47vO1b5XwLRwj8S9N6Jr5n1QCkIfAIH6umOSgqWZ4/v67hg6qq8Ha5vZonVidGsg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.14.1"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.9.tgz",
+      "integrity": "sha512-cuVNgarYWZqxRJDQHEB58GEONhOK79QVR/qYx4S7kcUObQvUwvFnYxJuuHUKm2aieN9X3yZB4LZsuYNU1Qphsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/uuid": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==",
+      "license": "MIT"
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.8.tgz",
+      "integrity": "sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.8",
+        "@esbuild/android-arm": "0.25.8",
+        "@esbuild/android-arm64": "0.25.8",
+        "@esbuild/android-x64": "0.25.8",
+        "@esbuild/darwin-arm64": "0.25.8",
+        "@esbuild/darwin-x64": "0.25.8",
+        "@esbuild/freebsd-arm64": "0.25.8",
+        "@esbuild/freebsd-x64": "0.25.8",
+        "@esbuild/linux-arm": "0.25.8",
+        "@esbuild/linux-arm64": "0.25.8",
+        "@esbuild/linux-ia32": "0.25.8",
+        "@esbuild/linux-loong64": "0.25.8",
+        "@esbuild/linux-mips64el": "0.25.8",
+        "@esbuild/linux-ppc64": "0.25.8",
+        "@esbuild/linux-riscv64": "0.25.8",
+        "@esbuild/linux-s390x": "0.25.8",
+        "@esbuild/linux-x64": "0.25.8",
+        "@esbuild/netbsd-arm64": "0.25.8",
+        "@esbuild/netbsd-x64": "0.25.8",
+        "@esbuild/openbsd-arm64": "0.25.8",
+        "@esbuild/openbsd-x64": "0.25.8",
+        "@esbuild/openharmony-arm64": "0.25.8",
+        "@esbuild/sunos-x64": "0.25.8",
+        "@esbuild/win32-arm64": "0.25.8",
+        "@esbuild/win32-ia32": "0.25.8",
+        "@esbuild/win32-x64": "0.25.8"
+      }
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.10.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz",
+      "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/hono": {
+      "version": "4.8.5",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.8.5.tgz",
+      "integrity": "sha512-Up2cQbtNz1s111qpnnECdTGqSIUIhZJMLikdKkshebQSEBcoUKq6XJayLGqSZWidiH0zfHRCJqFu062Mz5UuRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "deprecated": "Use your platform's native DOMException instead",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "4.20.3",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.20.3.tgz",
+      "integrity": "sha512-qjbnuR9Tr+FJOMBqJCW5ehvIo/buZq7vH7qD7JziU98h6l3qGy0a/yPFjwO+y0/T7GFpNgNAvEcPPVfyT8rrPQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.25.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/uuid": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz",
+      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

hono-proxy/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@colpali/proxy",
+  "version": "1.0.0",
+  "description": "Hono proxy server for ColPali Vespa Visual Retrieval",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "start:tsx": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.8.0",
+    "@types/uuid": "^10.0.0",
+    "dotenv": "^16.4.1",
+    "hono": "^4.0.0",
+    "node-fetch": "^3.3.2",
+    "uuid": "^9.0.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}

hono-proxy/src/config/index.ts

@@ -0,0 +1,44 @@
+import { config as dotenvConfig } from 'dotenv';
+import { z } from 'zod';
+
+dotenvConfig();
+
+const envSchema = z.object({
+  PORT: z.string().default('4025'),
+  BACKEND_URL: z.string().default('http://localhost:7860'),
+  VESPA_APP_URL: z.string().optional(),
+  VESPA_CERT_PATH: z.string().optional(),
+  VESPA_KEY_PATH: z.string().optional(),
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  CORS_ORIGIN: z.string().default('http://localhost:3000'),
+  CACHE_TTL: z.string().default('300'), // 5 minutes
+  ENABLE_CACHE: z.string().default('true'),
+  RATE_LIMIT_WINDOW: z.string().default('60000'), // 1 minute
+  RATE_LIMIT_MAX: z.string().default('100'),
+});
+
+const parsedEnv = envSchema.safeParse(process.env);
+
+if (!parsedEnv.success) {
+  console.error('❌ Invalid environment variables:', parsedEnv.error.format());
+  process.exit(1);
+}
+
+export const config = {
+  port: parseInt(parsedEnv.data.PORT),
+  backendUrl: parsedEnv.data.BACKEND_URL,
+  vespaAppUrl: parsedEnv.data.VESPA_APP_URL,
+  vespaCertPath: parsedEnv.data.VESPA_CERT_PATH,
+  vespaKeyPath: parsedEnv.data.VESPA_KEY_PATH,
+  nodeEnv: parsedEnv.data.NODE_ENV,
+  corsOrigin: parsedEnv.data.CORS_ORIGIN,
+  cacheTTL: parseInt(parsedEnv.data.CACHE_TTL),
+  enableCache: parsedEnv.data.ENABLE_CACHE === 'true',
+  rateLimit: {
+    windowMs: parseInt(parsedEnv.data.RATE_LIMIT_WINDOW),
+    max: parseInt(parsedEnv.data.RATE_LIMIT_MAX),
+  },
+};
+
+export const isDev = config.nodeEnv === 'development';
+export const isProd = config.nodeEnv === 'production';

hono-proxy/src/index.ts

@@ -0,0 +1,106 @@
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { compress } from 'hono/compress';
+import { secureHeaders } from 'hono/secure-headers';
+import { timeout } from 'hono/timeout';
+import { config } from './config';
+import { corsMiddleware } from './middleware/cors';
+import { loggerMiddleware, requestIdMiddleware } from './middleware/logger';
+import { rateLimitMiddleware } from './middleware/rateLimit';
+import { api } from './routes/api';
+import { backendApi } from './routes/backend-api';
+import { healthApp } from './routes/health';
+
+const app = new Hono();
+
+// Global middleware
+app.use('*', requestIdMiddleware);
+app.use('*', loggerMiddleware);
+app.use('*', corsMiddleware);
+app.use('*', secureHeaders());
+app.use('*', compress());
+
+// Apply rate limiting to API routes only
+app.use('/api/*', rateLimitMiddleware);
+
+// Apply timeout to prevent hanging requests (30 seconds, except for SSE)
+app.use('/api/*', async (c, next) => {
+  if (c.req.path === '/api/chat') {
+    // Skip timeout for SSE endpoints
+    await next();
+  } else {
+    return timeout(30000)(c, next);
+  }
+});
+
+// Mount routes - matching backend API structure at root level
+app.route('/', backendApi);
+
+// Also mount at /api for direct Next.js API access (optional)
+app.route('/api', api);
+
+// Health check
+app.route('/health', healthApp);
+
+// Root info endpoint
+app.get('/info', (c) => {
+  return c.json({
+    name: 'ColPali Hono Proxy',
+    version: '1.0.0',
+    endpoints: {
+      // Backend-compatible endpoints (Python API format)
+      search: '/fetch_results',
+      fullImage: '/full_image',
+      suggestions: '/suggestions',
+      similarityMaps: '/get_sim_map',
+      chat: '/get-message',
+      // Direct API endpoints
+      apiSearch: '/api/colpali-search',
+      apiFullImage: '/api/full-image',
+      apiSuggestions: '/api/query-suggestions',
+      apiSimilarityMaps: '/api/similarity-maps',
+      apiChat: '/api/visual-rag-chat',
+      health: '/health',
+    },
+  });
+});
+
+// 404 handler
+app.notFound((c) => {
+  return c.json({ error: 'Not found', path: c.req.path }, 404);
+});
+
+// Global error handler
+app.onError((err, c) => {
+  console.error(`Error handling request ${c.req.path}:`, err);
+  
+  if (err instanceof Error) {
+    if (err.message.includes('timeout')) {
+      return c.json({ error: 'Request timeout' }, 408);
+    }
+  }
+  
+  return c.json(
+    { 
+      error: 'Internal server error',
+      requestId: c.get('requestId'),
+    }, 
+    500
+  );
+});
+
+// Start server
+const port = config.port;
+
+console.log(`🚀 ColPali Hono Proxy starting...`);
+console.log(`📍 Backend URL: ${config.backendUrl}`);
+console.log(`🔒 CORS Origin: ${config.corsOrigin}`);
+console.log(`💾 Cache: ${config.enableCache ? 'Enabled' : 'Disabled'}`);
+console.log(`🚦 Rate Limit: ${config.rateLimit.max} requests per ${config.rateLimit.windowMs / 1000}s`);
+
+serve({
+  fetch: app.fetch,
+  port,
+}, (info) => {
+  console.log(`✅ Server running on http://localhost:${info.port}`);
+});

hono-proxy/src/middleware/cors.ts

@@ -0,0 +1,18 @@
+import { cors as honoCors } from 'hono/cors';
+import { config } from '../config';
+
+export const corsMiddleware = honoCors({
+  origin: (origin) => {
+    // Allow configured origin and localhost in development
+    const allowedOrigins = [config.corsOrigin];
+    if (config.nodeEnv === 'development') {
+      allowedOrigins.push('http://localhost:3000', 'http://localhost:3001', 'http://localhost:3025');
+    }
+    return allowedOrigins.includes(origin) ? origin : allowedOrigins[0];
+  },
+  allowHeaders: ['Content-Type', 'Authorization', 'X-Request-ID'],
+  allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+  exposeHeaders: ['X-Total-Count', 'X-Request-ID'],
+  maxAge: 86400,
+  credentials: true,
+});

hono-proxy/src/middleware/logger.ts

@@ -0,0 +1,13 @@
+import { Context, Next } from 'hono';
+import { logger } from 'hono/logger';
+
+export const loggerMiddleware = logger((str, ...rest) => {
+  console.log(str, ...rest);
+});
+
+export const requestIdMiddleware = async (c: Context, next: Next) => {
+  const requestId = c.req.header('X-Request-ID') || crypto.randomUUID();
+  c.set('requestId', requestId);
+  c.header('X-Request-ID', requestId);
+  await next();
+};

hono-proxy/src/middleware/rateLimit.ts

@@ -0,0 +1,54 @@
+import { Context, Next } from 'hono';
+import { config } from '../config';
+
+interface RateLimitStore {
+  [key: string]: {
+    count: number;
+    resetTime: number;
+  };
+}
+
+const store: RateLimitStore = {};
+
+// Simple in-memory rate limiter
+export const rateLimitMiddleware = async (c: Context, next: Next) => {
+  const ip = c.req.header('x-forwarded-for') || c.req.header('x-real-ip') || 'unknown';
+  const now = Date.now();
+  const windowStart = now - config.rateLimit.windowMs;
+
+  // Clean up old entries
+  Object.keys(store).forEach(key => {
+    if (store[key].resetTime < windowStart) {
+      delete store[key];
+    }
+  });
+
+  // Check rate limit
+  if (!store[ip]) {
+    store[ip] = { count: 1, resetTime: now + config.rateLimit.windowMs };
+  } else if (store[ip].resetTime < now) {
+    store[ip] = { count: 1, resetTime: now + config.rateLimit.windowMs };
+  } else {
+    store[ip].count++;
+  }
+
+  if (store[ip].count > config.rateLimit.max) {
+    return c.json(
+      { error: 'Too many requests', retryAfter: Math.ceil((store[ip].resetTime - now) / 1000) },
+      429,
+      {
+        'Retry-After': Math.ceil((store[ip].resetTime - now) / 1000).toString(),
+        'X-RateLimit-Limit': config.rateLimit.max.toString(),
+        'X-RateLimit-Remaining': '0',
+        'X-RateLimit-Reset': new Date(store[ip].resetTime).toISOString(),
+      }
+    );
+  }
+
+  // Add rate limit headers
+  c.header('X-RateLimit-Limit', config.rateLimit.max.toString());
+  c.header('X-RateLimit-Remaining', (config.rateLimit.max - store[ip].count).toString());
+  c.header('X-RateLimit-Reset', new Date(store[ip].resetTime).toISOString());
+
+  await next();
+};

hono-proxy/src/routes/api.ts

@@ -0,0 +1,274 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { v4 as uuidv4 } from 'uuid';
+import { z } from 'zod';
+import { config } from '../config';
+import { cache } from '../services/cache';
+import { vespaRequest } from '../services/vespa-https';
+
+const api = new Hono();
+
+// Search request schema
+const searchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'),
+});
+
+// Main search endpoint
+api.get('/colpali-search', async (c) => {
+  try {
+    const query = c.req.query('query');
+    const ranking = c.req.query('ranking') || 'hybrid';
+    
+    const validation = searchQuerySchema.safeParse({ query, ranking });
+    
+    if (!validation.success) {
+      return c.json({ error: 'Invalid request', details: validation.error.issues }, 400);
+    }
+
+    const validatedData = validation.data;
+    
+    // Check cache
+    const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`;
+    const cachedResult = cache.get(cacheKey);
+    
+    if (cachedResult) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedResult);
+    }
+
+    // Build YQL query based on ranking
+    let yql = '';
+    let rankProfile = 'default';
+    
+    switch (validatedData.ranking) {
+      case 'colpali':
+        yql = `select * from linqto where userQuery() limit 20`;
+        rankProfile = 'colpali';
+        break;
+      case 'bm25':
+        yql = `select * from linqto where userQuery() limit 20`;
+        rankProfile = 'bm25';
+        break;
+      case 'hybrid':
+      default:
+        yql = `select * from linqto where userQuery() limit 20`;
+        rankProfile = 'default';
+        break;
+    }
+
+    // Query Vespa directly
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const searchParams = new URLSearchParams({
+      yql,
+      query: validatedData.query,
+      ranking: rankProfile,
+      hits: '20'
+    });
+
+    const response = await vespaRequest(`${searchUrl}?${searchParams}`);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('Vespa error:', errorText);
+      throw new Error(`Vespa returned ${response.status}: ${errorText}`);
+    }
+
+    const data = await response.json();
+    
+    // Generate query_id for sim_map compatibility
+    const queryId = uuidv4();
+    
+    // Transform to match expected format
+    if (data.root && data.root.children) {
+      data.root.children.forEach((hit: any, idx: number) => {
+        if (!hit.fields) hit.fields = {};
+        // Add sim_map identifier for compatibility
+        hit.fields.sim_map = `${queryId}_${idx}`;
+      });
+    }
+
+    // Cache the result
+    cache.set(cacheKey, data);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Search error:', error);
+    return c.json({ 
+      error: 'Search failed', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Full image endpoint
+api.get('/full-image', async (c) => {
+  try {
+    const docId = c.req.query('docId');
+    
+    if (!docId) {
+      return c.json({ error: 'docId is required' }, 400);
+    }
+
+    // Check cache
+    const cacheKey = `fullimage:${docId}`;
+    const cachedImage = cache.get<{ base64_image: string }>(cacheKey);
+    
+    if (cachedImage) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedImage);
+    }
+
+    // Query Vespa for the document
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const searchParams = new URLSearchParams({
+      yql: `select * from linqto where id contains "${docId}"`,
+      hits: '1'
+    });
+
+    const response = await vespaRequest(`${searchUrl}?${searchParams}`);
+
+    if (!response.ok) {
+      throw new Error(`Vespa returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    if (data.root?.children?.[0]?.fields) {
+      const fields = data.root.children[0].fields;
+      const base64Image = fields.full_image || fields.image;
+      
+      if (base64Image) {
+        const result = { base64_image: base64Image };
+        cache.set(cacheKey, result, 86400); // 24 hours
+        c.header('X-Cache', 'MISS');
+        return c.json(result);
+      }
+    }
+    
+    return c.json({ error: 'Image not found' }, 404);
+  } catch (error) {
+    console.error('Full image error:', error);
+    return c.json({ 
+      error: 'Failed to fetch image', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Query suggestions endpoint
+api.get('/query-suggestions', async (c) => {
+  try {
+    const query = c.req.query('query');
+    
+    // Static suggestions for now
+    const staticSuggestions = [
+      'linqto bankruptcy',
+      'linqto filing date',
+      'linqto creditors',
+      'linqto assets',
+      'linqto liabilities',
+      'linqto chapter 11',
+      'linqto docket',
+      'linqto plan',
+      'linqto disclosure statement',
+      'linqto claims',
+    ];
+    
+    if (!query) {
+      return c.json({ suggestions: staticSuggestions.slice(0, 5) });
+    }
+
+    const lowerQuery = query.toLowerCase();
+    const filtered = staticSuggestions
+      .filter(s => s.toLowerCase().includes(lowerQuery))
+      .slice(0, 5);
+    
+    return c.json({ suggestions: filtered });
+  } catch (error) {
+    console.error('Suggestions error:', error);
+    return c.json({ 
+      error: 'Failed to fetch suggestions', 
+      suggestions: [] 
+    }, 500);
+  }
+});
+
+// Similarity maps endpoint (placeholder)
+api.get('/similarity-maps', async (c) => {
+  try {
+    const queryId = c.req.query('queryId');
+    const idx = c.req.query('idx');
+    const token = c.req.query('token');
+    const tokenIdx = c.req.query('tokenIdx');
+    
+    if (!queryId || !idx || !token || !tokenIdx) {
+      return c.json({ error: 'Missing required parameters' }, 400);
+    }
+
+    // Return placeholder HTML
+    const html = `
+      <div style="padding: 20px; text-align: center;">
+        <h3>Similarity Map</h3>
+        <p>Query: ${token}</p>
+        <p>Document: ${idx}</p>
+        <p style="color: #666;">
+          Similarity map generation requires the ColPali model.
+          This is a placeholder for the demo.
+        </p>
+      </div>
+    `;
+    
+    return c.html(html);
+  } catch (error) {
+    console.error('Similarity map error:', error);
+    return c.json({ 
+      error: 'Failed to generate similarity map', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Visual RAG Chat SSE endpoint
+api.get('/visual-rag-chat', async (c) => {
+  const queryId = c.req.query('queryId');
+  const query = c.req.query('query');
+  const docIds = c.req.query('docIds');
+
+  if (!queryId || !query || !docIds) {
+    return c.json({ error: 'Missing required parameters: queryId, query, docIds' }, 400);
+  }
+
+  return streamSSE(c, async (stream) => {
+    try {
+      // Mock response for now - in production this would use an LLM
+      const messages = [
+        `I'll analyze the search results for your query: "${query}"`,
+        "Based on the documents provided, here are the key findings:",
+        "1. LINQTO filed for Chapter 11 bankruptcy protection",
+        "2. The filing includes detailed financial statements and creditor information",
+        "3. Various claims and assets are documented in the court filings",
+        "",
+        "This is a demo response. In production, this would analyze the actual document contents using an LLM."
+      ];
+      
+      for (const msg of messages) {
+        await stream.writeSSE({ data: msg });
+        await new Promise(resolve => setTimeout(resolve, 300)); // Simulate typing
+      }
+    } catch (error) {
+      console.error('Chat streaming error:', error);
+      await stream.writeSSE({
+        event: 'error',
+        data: JSON.stringify({ 
+          error: 'Streaming failed', 
+          message: error instanceof Error ? error.message : 'Unknown error' 
+        }),
+      });
+    }
+  });
+});
+
+export { api };
+

hono-proxy/src/routes/backend-api.ts

@@ -0,0 +1,376 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { v4 as uuidv4 } from 'uuid';
+import { z } from 'zod';
+import { config } from '../config';
+import { cache } from '../services/cache';
+import { vespaRequest } from '../services/vespa-https';
+
+const backendApi = new Hono();
+
+// Search request schema
+const searchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'),
+});
+
+// Main search endpoint - /fetch_results
+backendApi.get('/fetch_results', async (c) => {
+  try {
+    const query = c.req.query('query');
+    const ranking = c.req.query('ranking') || 'hybrid';
+    
+    const validation = searchQuerySchema.safeParse({ query, ranking });
+    
+    if (!validation.success) {
+      return c.json({ error: 'Invalid request', details: validation.error.issues }, 400);
+    }
+
+    const validatedData = validation.data;
+    
+    // Check cache
+    const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`;
+    const cachedResult = cache.get(cacheKey);
+    
+    if (cachedResult) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedResult);
+    }
+
+    // Build YQL query based on ranking
+    let yql = '';
+    let searchParams: any = {
+      query: validatedData.query,
+      hits: '20'
+    };
+    
+    switch (validatedData.ranking) {
+      case 'colpali':
+        // Use retrieval-and-rerank profile for ColPali
+        yql = `select * from linqto where userQuery() limit 20`;
+        searchParams.ranking = 'retrieval-and-rerank';
+        break;
+      case 'bm25':
+        yql = `select * from linqto where userQuery() limit 20`;
+        searchParams.ranking = 'default';
+        break;
+      case 'hybrid':
+      default:
+        yql = `select * from linqto where userQuery() limit 20`;
+        searchParams.ranking = 'default';
+        break;
+    }
+
+    // For ColPali ranking, we need embeddings
+    let body: any = {};
+    let useNearestNeighbor = false;
+    
+    if (validatedData.ranking === 'colpali') {
+      try {
+        // Call embedding API to get query embeddings
+        const embeddingResponse = await fetch(
+          `http://localhost:7861/embed_query?query=${encodeURIComponent(validatedData.query)}`
+        );
+        
+        if (embeddingResponse.ok) {
+          const embeddingData = await embeddingResponse.json();
+          
+          // Create nearestNeighbor query string
+          const numTokens = Object.keys(embeddingData.embeddings.binary).length;
+          const maxTokens = Math.min(numTokens, 20); // Limit to 20 tokens to avoid timeouts
+          const nnClauses = [];
+          
+          // Add individual rq tensors for nearestNeighbor
+          for (let i = 0; i < maxTokens; i++) {
+            body[`input.query(rq${i})`] = embeddingData.embeddings.binary[i.toString()];
+            nnClauses.push(`({targetHits:10}nearestNeighbor(embedding,rq${i}))`);
+          }
+          
+          // Update YQL for nearestNeighbor search
+          if (nnClauses.length > 0) {
+            yql = `select * from linqto where ${nnClauses.join(' OR ')} limit 20`;
+            useNearestNeighbor = true;
+          }
+          
+          // Add qt and qtb for ranking
+          body["input.query(qt)"] = embeddingData.embeddings.float;
+          body["input.query(qtb)"] = embeddingData.embeddings.binary;
+          body["presentation.timing"] = true;
+        } else {
+          // Fall back to text-only search
+          searchParams.ranking = 'default';
+        }
+      } catch (error) {
+        console.log('Embedding API not available, falling back to text search');
+        searchParams.ranking = 'default';
+      }
+    }
+
+    // Query Vespa directly
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const urlSearchParams = new URLSearchParams({
+      yql,
+      ...searchParams
+    });
+    
+    // Use ranking.profile for Vespa instead of ranking
+    if (searchParams.ranking) {
+      urlSearchParams.delete('ranking');
+      urlSearchParams.set('ranking.profile', searchParams.ranking);
+    }
+    
+    const startTime = Date.now();
+    let requestOptions: any = {};
+    
+    // Only use POST with body if we have embeddings
+    if (Object.keys(body).length > 0) {
+      requestOptions = {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body)
+      };
+    } else {
+      requestOptions = {
+        method: 'GET'
+      };
+    }
+    
+    console.log('Vespa query URL:', `${searchUrl}?${urlSearchParams}`);
+    console.log('Request options:', requestOptions);
+    
+    const response = await vespaRequest(`${searchUrl}?${urlSearchParams}`, requestOptions);
+
+    if (!response.ok && response.status !== 504) {
+      const errorText = await response.text();
+      console.error('Vespa error:', errorText);
+      throw new Error(`Vespa returned ${response.status}: ${errorText}`);
+    }
+
+    const data = await response.json();
+    const searchTime = (Date.now() - startTime) / 1000; // Convert to seconds
+    
+    // Generate query_id for sim_map compatibility
+    const queryId = uuidv4();
+    
+    // Transform to match expected format
+    if (data.root && data.root.children) {
+      data.root.children.forEach((hit: any, idx: number) => {
+        if (!hit.fields) hit.fields = {};
+        // Add sim_map identifier for compatibility
+        hit.fields.sim_map = `${queryId}_${idx}`;
+      });
+    }
+
+    // Add timing information
+    data.timing = {
+      searchtime: searchTime
+    };
+
+    // Cache the result
+    cache.set(cacheKey, data);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Search error:', error);
+    return c.json({ 
+      error: 'Search failed', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Full image endpoint - /full_image
+backendApi.get('/full_image', async (c) => {
+  try {
+    const docId = c.req.query('doc_id'); // Note: backend expects doc_id, not docId
+    
+    if (!docId) {
+      return c.json({ error: 'doc_id is required' }, 400);
+    }
+
+    // Check cache
+    const cacheKey = `fullimage:${docId}`;
+    const cachedImage = cache.get<{ base64_image: string }>(cacheKey);
+    
+    if (cachedImage) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedImage);
+    }
+
+    // Query Vespa for the document
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const searchParams = new URLSearchParams({
+      yql: `select * from linqto where id contains "${docId}"`,
+      hits: '1'
+    });
+
+    const response = await vespaRequest(`${searchUrl}?${searchParams}`);
+
+    if (!response.ok) {
+      throw new Error(`Vespa returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    if (data.root?.children?.[0]?.fields) {
+      const fields = data.root.children[0].fields;
+      const base64Image = fields.full_image || fields.image;
+      
+      if (base64Image) {
+        const result = { base64_image: base64Image };
+        cache.set(cacheKey, result, 86400); // 24 hours
+        c.header('X-Cache', 'MISS');
+        return c.json(result);
+      }
+    }
+    
+    return c.json({ error: 'Image not found' }, 404);
+  } catch (error) {
+    console.error('Full image error:', error);
+    return c.json({ 
+      error: 'Failed to fetch image', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Query suggestions endpoint - /suggestions
+backendApi.get('/suggestions', async (c) => {
+  try {
+    const query = c.req.query('query') || '';
+    
+    // Static suggestions for now
+    const staticSuggestions = [
+      'linqto bankruptcy',
+      'linqto filing date',
+      'linqto creditors',
+      'linqto assets',
+      'linqto liabilities',
+      'linqto chapter 11',
+      'linqto docket',
+      'linqto plan',
+      'linqto disclosure statement',
+      'linqto claims',
+    ];
+    
+    if (!query) {
+      return c.json({ suggestions: staticSuggestions.slice(0, 5) });
+    }
+
+    const lowerQuery = query.toLowerCase();
+    const filtered = staticSuggestions
+      .filter(s => s.startsWith(lowerQuery))
+      .slice(0, 5);
+    
+    return c.json({ suggestions: filtered });
+  } catch (error) {
+    console.error('Suggestions error:', error);
+    return c.json({ 
+      error: 'Failed to fetch suggestions', 
+      suggestions: [] 
+    }, 500);
+  }
+});
+
+// Similarity maps endpoint - /get_sim_map
+backendApi.get('/get_sim_map', async (c) => {
+  try {
+    const queryId = c.req.query('query_id'); // Note: backend expects query_id
+    const idx = c.req.query('idx');
+    const token = c.req.query('token');
+    const tokenIdx = c.req.query('token_idx'); // Note: backend expects token_idx
+    
+    if (!queryId || !idx || !token || !tokenIdx) {
+      return c.json({ error: 'Missing required parameters' }, 400);
+    }
+
+    // Return placeholder HTML
+    const html = `
+      <div style="padding: 20px; text-align: center;">
+        <h3>Similarity Map</h3>
+        <p>Query: ${token}</p>
+        <p>Document: ${idx}</p>
+        <p style="color: #666;">
+          Similarity map generation requires the ColPali model.
+          This is a placeholder for the demo.
+        </p>
+      </div>
+    `;
+    
+    return c.html(html);
+  } catch (error) {
+    console.error('Similarity map error:', error);
+    return c.json({ 
+      error: 'Failed to generate similarity map', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Visual RAG Chat SSE endpoint - /get-message
+backendApi.get('/get-message', async (c) => {
+  const queryId = c.req.query('query_id'); // Note: backend expects query_id
+  const query = c.req.query('query');
+  const docIds = c.req.query('doc_ids'); // Note: backend expects doc_ids
+
+  if (!queryId || !query || !docIds) {
+    return c.json({ error: 'Missing required parameters: query_id, query, doc_ids' }, 400);
+  }
+
+  return streamSSE(c, async (stream) => {
+    try {
+      // Mock response for now - in production this would use an LLM
+      // Extract key information from the query
+      const messages = [];
+      
+      if (query.toLowerCase().includes('when') && query.toLowerCase().includes('file')) {
+        messages.push(
+          `I'll analyze the search results for your query: "${query}"`,
+          "",
+          "Based on the documents provided:",
+          "",
+          "**LINQTO filed for Chapter 11 bankruptcy on July 7, 2025**",
+          "",
+          "The filing was made in the United States Bankruptcy Court for the Southern District of Texas under case number 25-90186.",
+          "",
+          "Key details:",
+          "• Filing Date: July 7, 2025 (Petition Date)",
+          "• Court: Southern District of Texas",
+          "• Case Number: 25-90186",
+          "• Chapter: 11 (Reorganization)",
+          "",
+          "This is a demo response. In production, an LLM would analyze the actual document contents for more details."
+        );
+      } else {
+        messages.push(
+          `I'll analyze the search results for your query: "${query}"`,
+          "Based on the documents provided, here are the key findings:",
+          "1. LINQTO filed for Chapter 11 bankruptcy protection on July 7, 2025",
+          "2. The filing includes detailed financial statements and creditor information",
+          "3. Various claims and assets are documented in the court filings",
+          "",
+          "This is a demo response. In production, this would analyze the actual document contents using an LLM."
+        );
+      }
+      
+      for (const msg of messages) {
+        await stream.writeSSE({ data: msg });
+        await new Promise(resolve => setTimeout(resolve, 500)); // Simulate typing delay
+      }
+    } catch (error) {
+      console.error('Chat streaming error:', error);
+      await stream.writeSSE({
+        event: 'error',
+        data: JSON.stringify({ 
+          error: 'Streaming failed', 
+          message: error instanceof Error ? error.message : 'Unknown error' 
+        }),
+      });
+    }
+  });
+});
+
+export { backendApi };

hono-proxy/src/routes/chat-direct.ts

@@ -0,0 +1,46 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+
+const chatApp = new Hono();
+
+// Visual RAG Chat SSE endpoint
+chatApp.get('/', async (c) => {
+  const queryId = c.req.query('queryId');
+  const query = c.req.query('query');
+  const docIds = c.req.query('docIds');
+
+  if (!queryId || !query || !docIds) {
+    return c.json({ error: 'Missing required parameters: queryId, query, docIds' }, 400);
+  }
+
+  return streamSSE(c, async (stream) => {
+    try {
+      // Mock response for now - in production this would use an LLM
+      const messages = [
+        `I'll analyze the search results for your query: "${query}"`,
+        "Based on the documents provided, here are the key findings:",
+        "1. LINQTO filed for Chapter 11 bankruptcy protection",
+        "2. The filing includes detailed financial statements and creditor information",
+        "3. Various claims and assets are documented in the court filings",
+        "",
+        "This is a demo response. In production, this would analyze the actual document contents using an LLM."
+      ];
+      
+      for (const msg of messages) {
+        await stream.writeSSE({ data: msg });
+        await new Promise(resolve => setTimeout(resolve, 300)); // Simulate typing
+      }
+    } catch (error) {
+      console.error('Chat streaming error:', error);
+      await stream.writeSSE({
+        event: 'error',
+        data: JSON.stringify({ 
+          error: 'Streaming failed', 
+          message: error instanceof Error ? error.message : 'Unknown error' 
+        }),
+      });
+    }
+  });
+});
+
+export { chatApp };

hono-proxy/src/routes/chat.ts

@@ -0,0 +1,109 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { config } from '../config';
+
+const chatApp = new Hono();
+
+// Visual RAG Chat SSE endpoint - matches Next.js /api/visual-rag-chat
+chatApp.get('/', async (c) => {
+  const queryId = c.req.query('queryId');
+  const query = c.req.query('query');
+  const docIds = c.req.query('docIds');
+
+  if (!queryId || !query || !docIds) {
+    return c.json({ error: 'Missing required parameters: queryId, query, docIds' }, 400);
+  }
+
+  return streamSSE(c, async (stream) => {
+    try {
+      // Create abort controller for cleanup
+      const abortController = new AbortController();
+
+      // Forward request to backend /get-message endpoint
+      const chatUrl = `${config.backendUrl}/get-message?query_id=${encodeURIComponent(queryId)}&query=${encodeURIComponent(query)}&doc_ids=${encodeURIComponent(docIds)}`;
+      
+      const response = await fetch(chatUrl, {
+        headers: {
+          'Accept': 'text/event-stream',
+        },
+        signal: abortController.signal,
+      });
+
+      if (!response.ok) {
+        await stream.writeSSE({
+          event: 'error',
+          data: JSON.stringify({ error: `Backend returned ${response.status}` }),
+        });
+        return;
+      }
+
+      if (!response.body) {
+        await stream.writeSSE({
+          event: 'error',
+          data: JSON.stringify({ error: 'No response body' }),
+        });
+        return;
+      }
+
+      // Stream the response
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        
+        // Keep the last incomplete line in the buffer
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim() === '') continue;
+          
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            await stream.writeSSE({ data });
+          } else if (line.startsWith('event: ')) {
+            // Handle event lines if backend sends them
+            const event = line.slice(7).trim();
+            // Look for the next data line
+            const nextLineIndex = lines.indexOf(line) + 1;
+            if (nextLineIndex < lines.length) {
+              const nextLine = lines[nextLineIndex];
+              if (nextLine.startsWith('data: ')) {
+                const data = nextLine.slice(6);
+                await stream.writeSSE({ event, data });
+                lines.splice(nextLineIndex, 1); // Remove processed line
+              }
+            }
+          }
+        }
+      }
+
+      // Handle any remaining data in buffer
+      if (buffer.trim()) {
+        if (buffer.startsWith('data: ')) {
+          await stream.writeSSE({ data: buffer.slice(6) });
+        }
+      }
+
+      // Cleanup
+      abortController.abort();
+    } catch (error) {
+      console.error('Chat streaming error:', error);
+      await stream.writeSSE({
+        event: 'error',
+        data: JSON.stringify({ 
+          error: 'Streaming failed', 
+          message: error instanceof Error ? error.message : 'Unknown error' 
+        }),
+      });
+    }
+  });
+});
+
+export { chatApp };

hono-proxy/src/routes/colpali-search-vespa.ts

@@ -0,0 +1,107 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { config } from '../config';
+import { cache } from '../services/cache';
+
+const colpaliSearchApp = new Hono();
+
+// Search request schema
+const searchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'),
+});
+
+// Main search endpoint - direct to Vespa
+colpaliSearchApp.get('/', async (c) => {
+  try {
+    const query = c.req.query('query');
+    const ranking = c.req.query('ranking') || 'hybrid';
+    
+    const validation = searchQuerySchema.safeParse({ query, ranking });
+    
+    if (!validation.success) {
+      return c.json({ error: 'Invalid request', details: validation.error.issues }, 400);
+    }
+
+    const validatedData = validation.data;
+    
+    // Check cache
+    const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`;
+    const cachedResult = cache.get(cacheKey);
+    
+    if (cachedResult) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedResult);
+    }
+
+    // Prepare YQL query based on ranking type
+    let yql = '';
+    switch (validatedData.ranking) {
+      case 'colpali':
+        yql = `select * from linqto where userQuery() limit 20`;
+        break;
+      case 'bm25':
+        yql = `select * from linqto where userQuery() order by bm25_score desc limit 20`;
+        break;
+      case 'hybrid':
+      default:
+        yql = `select * from linqto where userQuery() | rank (reciprocal_rank_fusion(bm25_score, max_sim)) limit 20`;
+        break;
+    }
+
+    // Query Vespa directly
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const searchParams = new URLSearchParams({
+      yql,
+      query: validatedData.query,
+      ranking: validatedData.ranking === 'colpali' ? 'colpali' : 'default',
+      'summary': 'default',
+      'format': 'json'
+    });
+
+    // For now, using direct fetch without certificate authentication
+    // In production, you would use a proxy or configure certificates properly
+    const response = await fetch(`${searchUrl}?${searchParams}`, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`Vespa returned ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    // Transform to match expected format (add sim_map if needed)
+    const transformedData = {
+      ...data,
+      root: {
+        ...data.root,
+        children: data.root?.children?.map((hit: any, idx: number) => ({
+          ...hit,
+          fields: {
+            ...hit.fields,
+            // Add sim_map field if not present (for compatibility)
+            sim_map: hit.fields.sim_map || `sim_map_${idx}`,
+          }
+        })) || []
+      }
+    };
+
+    // Cache the result
+    cache.set(cacheKey, transformedData);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(transformedData);
+  } catch (error) {
+    console.error('Search error:', error);
+    return c.json({ 
+      error: 'Search failed', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+export { colpaliSearchApp };

hono-proxy/src/routes/colpali-search.ts

@@ -0,0 +1,61 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { config } from '../config';
+import { cache } from '../services/cache';
+
+const colpaliSearchApp = new Hono();
+
+// Search request schema for GET requests
+const searchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'),
+});
+
+// Main search endpoint - matches Next.js /api/colpali-search
+colpaliSearchApp.get('/', async (c) => {
+  try {
+    const query = c.req.query('query');
+    const ranking = c.req.query('ranking') || 'hybrid';
+    
+    const validation = searchQuerySchema.safeParse({ query, ranking });
+    
+    if (!validation.success) {
+      return c.json({ error: 'Invalid request', details: validation.error.issues }, 400);
+    }
+
+    const validatedData = validation.data;
+    
+    // Check cache
+    const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`;
+    const cachedResult = cache.get(cacheKey);
+    
+    if (cachedResult) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedResult);
+    }
+
+    // Proxy to backend /fetch_results endpoint
+    const searchUrl = `${config.backendUrl}/fetch_results?query=${encodeURIComponent(validatedData.query)}&ranking=${validatedData.ranking}`;
+    const response = await fetch(searchUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    // Cache the result
+    cache.set(cacheKey, data);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Search error:', error);
+    return c.json({ 
+      error: 'Search failed', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+export { colpaliSearchApp };

hono-proxy/src/routes/full-image.ts

@@ -0,0 +1,49 @@
+import { Hono } from 'hono';
+import { config } from '../config';
+import { cache } from '../services/cache';
+
+const fullImageApp = new Hono();
+
+// Full image endpoint - matches Next.js /api/full-image
+fullImageApp.get('/', async (c) => {
+  try {
+    const docId = c.req.query('docId');
+    
+    if (!docId) {
+      return c.json({ error: 'docId is required' }, 400);
+    }
+
+    // Check cache
+    const cacheKey = `fullimage:${docId}`;
+    const cachedImage = cache.get<{ base64_image: string }>(cacheKey);
+    
+    if (cachedImage) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedImage);
+    }
+
+    // Proxy to backend
+    const imageUrl = `${config.backendUrl}/full_image?doc_id=${encodeURIComponent(docId)}`;
+    const response = await fetch(imageUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // Cache for 24 hours
+    cache.set(cacheKey, data, 86400);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Full image error:', error);
+    return c.json({ 
+      error: 'Failed to fetch image', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+export { fullImageApp };

hono-proxy/src/routes/health.ts

@@ -0,0 +1,101 @@
+import { Hono } from 'hono';
+import { config } from '../config';
+
+const healthApp = new Hono();
+
+interface HealthStatus {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  timestamp: string;
+  uptime: number;
+  services: {
+    backend: {
+      status: 'up' | 'down';
+      responseTime?: number;
+      error?: string;
+    };
+    cache: {
+      status: 'up' | 'down';
+      size?: number;
+    };
+  };
+}
+
+// Basic health check
+healthApp.get('/', async (c) => {
+  const startTime = Date.now();
+  const health: HealthStatus = {
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    services: {
+      backend: { status: 'down' },
+      cache: { status: 'up' },
+    },
+  };
+
+  // Check backend health
+  try {
+    const backendStart = Date.now();
+    const response = await fetch(`${config.backendUrl}/health`, {
+      signal: AbortSignal.timeout(5000), // 5 second timeout
+    });
+    
+    if (response.ok) {
+      health.services.backend = {
+        status: 'up',
+        responseTime: Date.now() - backendStart,
+      };
+    } else {
+      health.services.backend = {
+        status: 'down',
+        error: `HTTP ${response.status}`,
+      };
+      health.status = 'degraded';
+    }
+  } catch (error) {
+    health.services.backend = {
+      status: 'down',
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+    health.status = 'degraded';
+  }
+
+  // Overall health determination
+  const allServicesUp = Object.values(health.services).every(s => s.status === 'up');
+  if (!allServicesUp) {
+    health.status = 'degraded';
+  }
+
+  // Return appropriate status code
+  const statusCode = health.status === 'healthy' ? 200 : 503;
+  
+  return c.json(health, statusCode);
+});
+
+// Liveness probe (for k8s)
+healthApp.get('/live', (c) => {
+  return c.json({ status: 'alive', timestamp: new Date().toISOString() });
+});
+
+// Readiness probe (for k8s)
+healthApp.get('/ready', async (c) => {
+  try {
+    // Quick check if backend is reachable
+    const response = await fetch(`${config.backendUrl}/health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    
+    if (response.ok) {
+      return c.json({ ready: true });
+    }
+    
+    return c.json({ ready: false, reason: 'Backend not ready' }, 503);
+  } catch (error) {
+    return c.json({ 
+      ready: false, 
+      reason: error instanceof Error ? error.message : 'Unknown error' 
+    }, 503);
+  }
+});
+
+export { healthApp };

hono-proxy/src/routes/query-suggestions-vespa.ts

@@ -0,0 +1,60 @@
+import { Hono } from 'hono';
+import { cache } from '../services/cache';
+
+const querySuggestionsApp = new Hono();
+
+// Static suggestions for now (can be replaced with Vespa query later)
+const staticSuggestions = [
+  'linqto bankruptcy',
+  'linqto filing date',
+  'linqto creditors',
+  'linqto assets',
+  'linqto liabilities',
+  'linqto chapter 11',
+  'linqto docket',
+  'linqto plan',
+  'linqto disclosure statement',
+  'linqto claims',
+];
+
+// Query suggestions endpoint
+querySuggestionsApp.get('/', async (c) => {
+  try {
+    const query = c.req.query('query');
+    
+    if (!query) {
+      return c.json({ suggestions: [] });
+    }
+
+    // Check cache
+    const cacheKey = `suggestions:${query}`;
+    const cachedSuggestions = cache.get(cacheKey);
+    
+    if (cachedSuggestions) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedSuggestions);
+    }
+
+    // Filter static suggestions based on query
+    const lowerQuery = query.toLowerCase();
+    const filteredSuggestions = staticSuggestions
+      .filter(s => s.toLowerCase().includes(lowerQuery))
+      .slice(0, 5);
+
+    const result = { suggestions: filteredSuggestions };
+    
+    // Cache for 5 minutes
+    cache.set(cacheKey, result, 300);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(result);
+  } catch (error) {
+    console.error('Suggestions error:', error);
+    return c.json({ 
+      error: 'Failed to fetch suggestions', 
+      suggestions: [] 
+    }, 500);
+  }
+});
+
+export { querySuggestionsApp };

hono-proxy/src/routes/query-suggestions.ts

@@ -0,0 +1,49 @@
+import { Hono } from 'hono';
+import { config } from '../config';
+import { cache } from '../services/cache';
+
+const querySuggestionsApp = new Hono();
+
+// Query suggestions endpoint - matches Next.js /api/query-suggestions
+querySuggestionsApp.get('/', async (c) => {
+  try {
+    const query = c.req.query('query');
+    
+    if (!query) {
+      return c.json({ suggestions: [] });
+    }
+
+    // Check cache
+    const cacheKey = `suggestions:${query}`;
+    const cachedSuggestions = cache.get(cacheKey);
+    
+    if (cachedSuggestions) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedSuggestions);
+    }
+
+    // Proxy to backend
+    const suggestionsUrl = `${config.backendUrl}/suggestions?query=${encodeURIComponent(query)}`;
+    const response = await fetch(suggestionsUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // Cache for 5 minutes
+    cache.set(cacheKey, data, 300);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Suggestions error:', error);
+    return c.json({ 
+      error: 'Failed to fetch suggestions', 
+      suggestions: [] 
+    }, 500);
+  }
+});
+
+export { querySuggestionsApp };

hono-proxy/src/routes/search-direct.ts

@@ -0,0 +1,230 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { config } from '../config';
+import { cache } from '../services/cache';
+import { vespaRequest } from '../services/vespa-https';
+import { v4 as uuidv4 } from 'uuid';
+
+const searchApp = new Hono();
+
+// Search request schema
+const searchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'),
+});
+
+// Main search endpoint - direct to Vespa
+searchApp.get('/', async (c) => {
+  try {
+    const query = c.req.query('query');
+    const ranking = c.req.query('ranking') || 'hybrid';
+    
+    const validation = searchQuerySchema.safeParse({ query, ranking });
+    
+    if (!validation.success) {
+      return c.json({ error: 'Invalid request', details: validation.error.issues }, 400);
+    }
+
+    const validatedData = validation.data;
+    
+    // Check cache
+    const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`;
+    const cachedResult = cache.get(cacheKey);
+    
+    if (cachedResult) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedResult);
+    }
+
+    // Build YQL query based on ranking
+    let yql = '';
+    let rankProfile = 'default';
+    
+    switch (validatedData.ranking) {
+      case 'colpali':
+        yql = `select * from linqto where userQuery() limit 20`;
+        rankProfile = 'colpali';
+        break;
+      case 'bm25':
+        yql = `select * from linqto where userQuery() order by bm25_score desc limit 20`;
+        break;
+      case 'hybrid':
+      default:
+        yql = `select * from linqto where userQuery() | rank (reciprocal_rank_fusion(bm25_score, max_sim)) limit 20`;
+        break;
+    }
+
+    // Query Vespa directly
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const searchParams = new URLSearchParams({
+      yql,
+      query: validatedData.query,
+      ranking: rankProfile,
+      hits: '20'
+    });
+
+    const response = await vespaRequest(`${searchUrl}?${searchParams}`);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('Vespa error:', errorText);
+      throw new Error(`Vespa returned ${response.status}: ${errorText}`);
+    }
+
+    const data = await response.json();
+    
+    // Generate query_id for sim_map compatibility
+    const queryId = uuidv4();
+    
+    // Transform to match expected format
+    if (data.root && data.root.children) {
+      data.root.children.forEach((hit: any, idx: number) => {
+        if (!hit.fields) hit.fields = {};
+        // Add sim_map identifier for compatibility
+        hit.fields.sim_map = `${queryId}_${idx}`;
+      });
+    }
+
+    // Cache the result
+    cache.set(cacheKey, data);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Search error:', error);
+    return c.json({ 
+      error: 'Search failed', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Full image endpoint
+searchApp.get('/full-image', async (c) => {
+  try {
+    const docId = c.req.query('docId');
+    
+    if (!docId) {
+      return c.json({ error: 'docId is required' }, 400);
+    }
+
+    // Check cache
+    const cacheKey = `fullimage:${docId}`;
+    const cachedImage = cache.get<{ base64_image: string }>(cacheKey);
+    
+    if (cachedImage) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedImage);
+    }
+
+    // Query Vespa for the document
+    const searchUrl = `${config.vespaAppUrl}/search/`;
+    const searchParams = new URLSearchParams({
+      yql: `select * from linqto where id contains "${docId}"`,
+      hits: '1'
+    });
+
+    const response = await vespaRequest(`${searchUrl}?${searchParams}`);
+
+    if (!response.ok) {
+      throw new Error(`Vespa returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    if (data.root?.children?.[0]?.fields) {
+      const fields = data.root.children[0].fields;
+      const base64Image = fields.full_image || fields.image;
+      
+      if (base64Image) {
+        const result = { base64_image: base64Image };
+        cache.set(cacheKey, result, 86400); // 24 hours
+        c.header('X-Cache', 'MISS');
+        return c.json(result);
+      }
+    }
+    
+    return c.json({ error: 'Image not found' }, 404);
+  } catch (error) {
+    console.error('Full image error:', error);
+    return c.json({ 
+      error: 'Failed to fetch image', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Query suggestions endpoint
+searchApp.get('/suggestions', async (c) => {
+  try {
+    const query = c.req.query('query');
+    
+    // Static suggestions for now
+    const staticSuggestions = [
+      'linqto bankruptcy',
+      'linqto filing date',
+      'linqto creditors',
+      'linqto assets',
+      'linqto liabilities',
+      'linqto chapter 11',
+      'linqto docket',
+      'linqto plan',
+      'linqto disclosure statement',
+      'linqto claims',
+    ];
+    
+    if (!query) {
+      return c.json({ suggestions: staticSuggestions.slice(0, 5) });
+    }
+
+    const lowerQuery = query.toLowerCase();
+    const filtered = staticSuggestions
+      .filter(s => s.toLowerCase().includes(lowerQuery))
+      .slice(0, 5);
+    
+    return c.json({ suggestions: filtered });
+  } catch (error) {
+    console.error('Suggestions error:', error);
+    return c.json({ 
+      error: 'Failed to fetch suggestions', 
+      suggestions: [] 
+    }, 500);
+  }
+});
+
+// Similarity maps endpoint (placeholder)
+searchApp.get('/similarity-maps', async (c) => {
+  try {
+    const queryId = c.req.query('queryId');
+    const idx = c.req.query('idx');
+    const token = c.req.query('token');
+    const tokenIdx = c.req.query('tokenIdx');
+    
+    if (!queryId || !idx || !token || !tokenIdx) {
+      return c.json({ error: 'Missing required parameters' }, 400);
+    }
+
+    // Return placeholder HTML
+    const html = `
+      <div style="padding: 20px; text-align: center;">
+        <h3>Similarity Map</h3>
+        <p>Query: ${token}</p>
+        <p>Document: ${idx}</p>
+        <p style="color: #666;">
+          Similarity map generation requires the ColPali model.
+          This is a placeholder for the demo.
+        </p>
+      </div>
+    `;
+    
+    return c.html(html);
+  } catch (error) {
+    console.error('Similarity map error:', error);
+    return c.json({ 
+      error: 'Failed to generate similarity map', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+export { searchApp };

hono-proxy/src/routes/search.ts

@@ -0,0 +1,178 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { config } from '../config';
+import { cache, cacheKeys } from '../services/cache';
+
+const searchApp = new Hono();
+
+// Search request schema for GET requests
+const searchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'),
+});
+
+// Main search endpoint - matches Next.js /api/colpali-search
+searchApp.get('/', async (c) => {
+  try {
+    const query = c.req.query('query');
+    const ranking = c.req.query('ranking') || 'hybrid';
+    
+    const validation = searchQuerySchema.safeParse({ query, ranking });
+    
+    if (!validation.success) {
+      return c.json({ error: 'Invalid request', details: validation.error.issues }, 400);
+    }
+
+    const validatedData = validation.data;
+    
+    // Check cache
+    const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`;
+    const cachedResult = cache.get(cacheKey);
+    
+    if (cachedResult) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedResult);
+    }
+
+    // Proxy to backend /fetch_results endpoint
+    const searchUrl = `${config.backendUrl}/fetch_results?query=${encodeURIComponent(validatedData.query)}&ranking=${validatedData.ranking}`;
+    const response = await fetch(searchUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    // Cache the result
+    cache.set(cacheKey, data);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Search error:', error);
+    return c.json({ 
+      error: 'Search failed', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Full image endpoint - matches Next.js /api/full-image
+searchApp.get('/full-image', async (c) => {
+  try {
+    const docId = c.req.query('docId');
+    
+    if (!docId) {
+      return c.json({ error: 'docId is required' }, 400);
+    }
+
+    // Check cache
+    const cacheKey = `fullimage:${docId}`;
+    const cachedImage = cache.get<{ base64_image: string }>(cacheKey);
+    
+    if (cachedImage) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedImage);
+    }
+
+    // Proxy to backend
+    const imageUrl = `${config.backendUrl}/full_image?doc_id=${encodeURIComponent(docId)}`;
+    const response = await fetch(imageUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // Cache for 24 hours
+    cache.set(cacheKey, data, 86400);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Full image error:', error);
+    return c.json({ 
+      error: 'Failed to fetch image', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+// Query suggestions endpoint - matches Next.js /api/query-suggestions
+searchApp.get('/suggestions', async (c) => {
+  try {
+    const query = c.req.query('query');
+    
+    if (!query) {
+      return c.json({ suggestions: [] });
+    }
+
+    // Check cache
+    const cacheKey = `suggestions:${query}`;
+    const cachedSuggestions = cache.get(cacheKey);
+    
+    if (cachedSuggestions) {
+      c.header('X-Cache', 'HIT');
+      return c.json(cachedSuggestions);
+    }
+
+    // Proxy to backend
+    const suggestionsUrl = `${config.backendUrl}/suggestions?query=${encodeURIComponent(query)}`;
+    const response = await fetch(suggestionsUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // Cache for 5 minutes
+    cache.set(cacheKey, data, 300);
+    c.header('X-Cache', 'MISS');
+
+    return c.json(data);
+  } catch (error) {
+    console.error('Suggestions error:', error);
+    return c.json({ 
+      error: 'Failed to fetch suggestions', 
+      suggestions: [] 
+    }, 500);
+  }
+});
+
+// Similarity maps endpoint - matches Next.js /api/similarity-maps
+searchApp.get('/similarity-maps', async (c) => {
+  try {
+    const queryId = c.req.query('queryId');
+    const idx = c.req.query('idx');
+    const token = c.req.query('token');
+    const tokenIdx = c.req.query('tokenIdx');
+    
+    if (!queryId || !idx || !token || !tokenIdx) {
+      return c.json({ error: 'Missing required parameters' }, 400);
+    }
+
+    // Note: Similarity maps are dynamic, so no caching
+    const simMapUrl = `${config.backendUrl}/get_sim_map?query_id=${encodeURIComponent(queryId)}&idx=${idx}&token=${encodeURIComponent(token)}&token_idx=${tokenIdx}`;
+    const response = await fetch(simMapUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    // Backend returns HTML, so we need to return it as text
+    const html = await response.text();
+    
+    return c.html(html);
+  } catch (error) {
+    console.error('Similarity map error:', error);
+    return c.json({ 
+      error: 'Failed to generate similarity map', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+export { searchApp };

hono-proxy/src/routes/similarity-maps.ts

@@ -0,0 +1,39 @@
+import { Hono } from 'hono';
+import { config } from '../config';
+
+const similarityMapsApp = new Hono();
+
+// Similarity maps endpoint - matches Next.js /api/similarity-maps
+similarityMapsApp.get('/', async (c) => {
+  try {
+    const queryId = c.req.query('queryId');
+    const idx = c.req.query('idx');
+    const token = c.req.query('token');
+    const tokenIdx = c.req.query('tokenIdx');
+    
+    if (!queryId || !idx || !token || !tokenIdx) {
+      return c.json({ error: 'Missing required parameters' }, 400);
+    }
+
+    // Note: Similarity maps are dynamic, so no caching
+    const simMapUrl = `${config.backendUrl}/get_sim_map?query_id=${encodeURIComponent(queryId)}&idx=${idx}&token=${encodeURIComponent(token)}&token_idx=${tokenIdx}`;
+    const response = await fetch(simMapUrl);
+
+    if (!response.ok) {
+      throw new Error(`Backend returned ${response.status}`);
+    }
+
+    // Backend returns HTML, so we need to return it as text
+    const html = await response.text();
+    
+    return c.html(html);
+  } catch (error) {
+    console.error('Similarity map error:', error);
+    return c.json({ 
+      error: 'Failed to generate similarity map', 
+      message: error instanceof Error ? error.message : 'Unknown error' 
+    }, 500);
+  }
+});
+
+export { similarityMapsApp };

hono-proxy/src/routes/visual-rag-chat.ts

@@ -0,0 +1,109 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { config } from '../config';
+
+const visualRagChatApp = new Hono();
+
+// Visual RAG Chat SSE endpoint - matches Next.js /api/visual-rag-chat
+visualRagChatApp.get('/', async (c) => {
+  const queryId = c.req.query('queryId');
+  const query = c.req.query('query');
+  const docIds = c.req.query('docIds');
+
+  if (!queryId || !query || !docIds) {
+    return c.json({ error: 'Missing required parameters: queryId, query, docIds' }, 400);
+  }
+
+  return streamSSE(c, async (stream) => {
+    try {
+      // Create abort controller for cleanup
+      const abortController = new AbortController();
+
+      // Forward request to backend /get-message endpoint
+      const chatUrl = `${config.backendUrl}/get-message?query_id=${encodeURIComponent(queryId)}&query=${encodeURIComponent(query)}&doc_ids=${encodeURIComponent(docIds)}`;
+      
+      const response = await fetch(chatUrl, {
+        headers: {
+          'Accept': 'text/event-stream',
+        },
+        signal: abortController.signal,
+      });
+
+      if (!response.ok) {
+        await stream.writeSSE({
+          event: 'error',
+          data: JSON.stringify({ error: `Backend returned ${response.status}` }),
+        });
+        return;
+      }
+
+      if (!response.body) {
+        await stream.writeSSE({
+          event: 'error',
+          data: JSON.stringify({ error: 'No response body' }),
+        });
+        return;
+      }
+
+      // Stream the response
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        
+        // Keep the last incomplete line in the buffer
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim() === '') continue;
+          
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            await stream.writeSSE({ data });
+          } else if (line.startsWith('event: ')) {
+            // Handle event lines if backend sends them
+            const event = line.slice(7).trim();
+            // Look for the next data line
+            const nextLineIndex = lines.indexOf(line) + 1;
+            if (nextLineIndex < lines.length) {
+              const nextLine = lines[nextLineIndex];
+              if (nextLine.startsWith('data: ')) {
+                const data = nextLine.slice(6);
+                await stream.writeSSE({ event, data });
+                lines.splice(nextLineIndex, 1); // Remove processed line
+              }
+            }
+          }
+        }
+      }
+
+      // Handle any remaining data in buffer
+      if (buffer.trim()) {
+        if (buffer.startsWith('data: ')) {
+          await stream.writeSSE({ data: buffer.slice(6) });
+        }
+      }
+
+      // Cleanup
+      abortController.abort();
+    } catch (error) {
+      console.error('Chat streaming error:', error);
+      await stream.writeSSE({
+        event: 'error',
+        data: JSON.stringify({ 
+          error: 'Streaming failed', 
+          message: error instanceof Error ? error.message : 'Unknown error' 
+        }),
+      });
+    }
+  });
+});
+
+export { visualRagChatApp };

hono-proxy/src/services/cache.ts

@@ -0,0 +1,68 @@
+import { config } from '../config';
+
+interface CacheEntry<T> {
+  data: T;
+  expiry: number;
+}
+
+class InMemoryCache {
+  private cache: Map<string, CacheEntry<any>> = new Map();
+  private cleanupInterval: NodeJS.Timeout;
+
+  constructor() {
+    // Cleanup expired entries every minute
+    this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+  }
+
+  set<T>(key: string, value: T, ttl: number = config.cacheTTL): void {
+    if (!config.enableCache) return;
+    
+    const expiry = Date.now() + (ttl * 1000);
+    this.cache.set(key, { data: value, expiry });
+  }
+
+  get<T>(key: string): T | null {
+    if (!config.enableCache) return null;
+    
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    
+    if (Date.now() > entry.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+    
+    return entry.data as T;
+  }
+
+  delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiry) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  destroy(): void {
+    clearInterval(this.cleanupInterval);
+    this.cache.clear();
+  }
+}
+
+export const cache = new InMemoryCache();
+
+// Cache key generators
+export const cacheKeys = {
+  search: (query: string, limit: number) => `search:${query}:${limit}`,
+  image: (docId: string, type: 'thumbnail' | 'full') => `image:${docId}:${type}`,
+  similarityMap: (docId: string, query: string) => `similarity:${docId}:${query}`,
+};

hono-proxy/src/services/vespa-client-simple.ts

@@ -0,0 +1,23 @@
+import { config } from '../config';
+
+// For now, we'll use regular fetch without certificate support
+// This requires Vespa to be configured with token authentication
+// or to have a proxy that handles certificates
+
+export async function vespaFetch(url: string, options: RequestInit = {}) {
+  // Since browser fetch doesn't support client certificates,
+  // we'll need to either:
+  // 1. Use token authentication (if configured in Vespa)
+  // 2. Set up a proxy that handles certificates
+  // 3. Use the Python backend as a proxy
+  
+  // For now, we'll attempt direct connection
+  // This will work if Vespa is configured for public access or token auth
+  return fetch(url, {
+    ...options,
+    headers: {
+      ...options.headers,
+      'Accept': 'application/json',
+    }
+  });
+}

hono-proxy/src/services/vespa-client.ts

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import * as https from 'https';
+import { config } from '../config';
+
+// Create HTTPS agent with certificate authentication
+let httpsAgent: https.Agent | undefined;
+
+if (config.vespaCertPath && config.vespaKeyPath) {
+  try {
+    httpsAgent = new https.Agent({
+      cert: fs.readFileSync(config.vespaCertPath),
+      key: fs.readFileSync(config.vespaKeyPath),
+      rejectUnauthorized: false
+    });
+  } catch (error) {
+    console.error('Failed to load Vespa certificates:', error);
+  }
+}
+
+export async function vespaFetch(url: string, options: RequestInit = {}) {
+  // For Node.js 18+, we need to use undici or node-fetch with agent support
+  const fetch = globalThis.fetch;
+  
+  if (httpsAgent) {
+    // @ts-ignore - agent is not in standard fetch types but works in Node.js
+    return fetch(url, {
+      ...options,
+      agent: httpsAgent
+    });
+  }
+  
+  return fetch(url, options);
+}

hono-proxy/src/services/vespa-https.ts

@@ -0,0 +1,102 @@
+import * as https from 'https';
+import * as fs from 'fs';
+import { config } from '../config';
+
+interface VespaRequestOptions {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string;
+}
+
+export async function vespaRequest(url: string, options: VespaRequestOptions = {}): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    
+    const httpsOptions: https.RequestOptions = {
+      hostname: urlObj.hostname,
+      port: 443,
+      path: urlObj.pathname + urlObj.search,
+      method: options.method || 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        ...options.headers
+      }
+    };
+
+    // Add certificate authentication if available
+    if (config.vespaCertPath && config.vespaKeyPath) {
+      try {
+        httpsOptions.cert = fs.readFileSync(config.vespaCertPath);
+        httpsOptions.key = fs.readFileSync(config.vespaKeyPath);
+        httpsOptions.rejectUnauthorized = false;
+      } catch (error) {
+        console.error('Failed to load certificates:', error);
+      }
+    }
+
+    const req = https.request(httpsOptions, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            resolve({
+              ok: true,
+              status: res.statusCode,
+              json: async () => JSON.parse(data),
+              text: async () => data
+            });
+          } catch (error) {
+            reject(error);
+          }
+        } else if (res.statusCode === 504) {
+          // Handle timeout as success if we got data
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.root && parsed.root.children) {
+              resolve({
+                ok: false,  // Keep ok: false for proper handling
+                status: res.statusCode,
+                json: async () => parsed,
+                text: async () => data
+              });
+            } else {
+              resolve({
+                ok: false,
+                status: res.statusCode,
+                text: async () => data
+              });
+            }
+          } catch (error) {
+            resolve({
+              ok: false,
+              status: res.statusCode,
+              text: async () => data
+            });
+          }
+        } else {
+          resolve({
+            ok: false,
+            status: res.statusCode,
+            text: async () => data
+          });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    if (options.body) {
+      req.write(options.body);
+    }
+
+    req.end();
+  });
+}

hono-proxy/start.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# ColPali Hono Proxy Quick Start Script
+
+echo "🚀 ColPali Hono Proxy Setup"
+echo "=========================="
+
+# Check if .env exists
+if [ ! -f .env ]; then
+    echo "📝 Creating .env file from template..."
+    cp .env.example .env
+    echo "⚠️  Please update .env with your configuration"
+    echo ""
+fi
+
+# Install dependencies if needed
+if [ ! -d "node_modules" ]; then
+    echo "📦 Installing dependencies..."
+    npm install
+    echo ""
+fi
+
+# Check if backend is running
+echo "🔍 Checking backend connection..."
+BACKEND_URL=${BACKEND_URL:-http://localhost:7860}
+if curl -f -s "$BACKEND_URL/health" > /dev/null; then
+    echo "✅ Backend is reachable at $BACKEND_URL"
+else
+    echo "⚠️  Warning: Backend at $BACKEND_URL is not responding"
+    echo "   Make sure your ColPali backend is running"
+fi
+echo ""
+
+# Start the server
+echo "🚀 Starting Hono proxy server..."
+echo "   API URL: http://localhost:4000/api"
+echo "   Health: http://localhost:4000/health"
+echo ""
+
+npm run dev

hono-proxy/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

requirements_embedding.txt

@@ -0,0 +1,9 @@
+fastapi==0.109.0
+uvicorn==0.25.0
+torch>=2.0.0
+torchvision
+transformers>=4.36.0
+colpali-engine>=0.2.0
+numpy
+Pillow
+python-multipart

vespa-certs/data-plane-private-key.pem

@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgPilyxGAC2u3U8UJt
+/ge1POIYBISa6kK5wkREPFEQBEWhRANCAARU7WOc2KNJIVKVZi+Q/yhB56gRedqe
+X31rKMcTiV3i6ub/JZ2Vb0Uu3Uh5z8pR+8BDsDA2Z/kegHZ/SCNumdc9
+-----END PRIVATE KEY-----

vespa-certs/data-plane-public-cert.pem

@@ -0,0 +1,9 @@
+-----BEGIN CERTIFICATE-----
+MIIBOTCB36ADAgECAhEAw/MfxwQkH780EYUSADpR/zAKBggqhkjOPQQDAjAeMRww
+GgYDVQQDExNjbG91ZC52ZXNwYS5leGFtcGxlMB4XDTI1MDcyMzA5NTA0OVoXDTM1
+MDcyMTA5NTA0OVowHjEcMBoGA1UEAxMTY2xvdWQudmVzcGEuZXhhbXBsZTBZMBMG
+ByqGSM49AgEGCCqGSM49AwEHA0IABFTtY5zYo0khUpVmL5D/KEHnqBF52p5ffWso
+xxOJXeLq5v8lnZVvRS7dSHnPylH7wEOwMDZn+R6Adn9II26Z1z0wCgYIKoZIzj0E
+AwIDSQAwRgIhANn7YhE5UkGItamxHas6lJjhhKoWIhSIsUMEmaXuiIZZAiEAvBEQ
+YHCIi5v6LeeOwD0bkkVP/Rkny7q/4oc9ag3lU/0=
+-----END CERTIFICATE-----