voyageai-cli 1.20.5 → 1.21.0

package/src/lib/templates/nextjs/route-search.js.tpl

@@ -0,0 +1,97 @@
+/**
+ * Search API Route Handler
+ * Generated by vai v{{vaiVersion}} on {{generatedAt}}
+ * 
+ * POST /api/search
+ */
+
+import { NextResponse } from 'next/server';
+import { embedQuery{{#if rerank}}, rerank{{/if}} } from '@/lib/voyage';
+import { vectorSearch } from '@/lib/mongodb';
+
+export async function POST(request) {
+  const start = Date.now();
+  
+  try {
+    const body = await request.json();
+    const { query, limit = 5, includeContext = false, filter } = body;
+    
+    if (!query || typeof query !== 'string') {
+      return NextResponse.json(
+        { error: 'Query is required' },
+        { status: 400 }
+      );
+    }
+    
+{{#if rerank}}
+    const candidates = body.candidates || 20;
+{{/if}}
+    
+    // Step 1: Embed the query
+    const queryEmbedding = await embedQuery(query);
+    
+    // Step 2: Vector search
+{{#if rerank}}
+    const searchResults = await vectorSearch(queryEmbedding, {
+      limit: candidates,
+      filter,
+    });
+{{else}}
+    const searchResults = await vectorSearch(queryEmbedding, {
+      limit,
+      filter,
+    });
+{{/if}}
+    
+    if (searchResults.length === 0) {
+      return NextResponse.json({
+        results: [],
+        meta: {
+          model: '{{model}}',
+          took: Date.now() - start,
+        },
+      });
+    }
+    
+{{#if rerank}}
+    // Step 3: Rerank for better relevance
+    const documents = searchResults.map(r => r.document.text);
+    const { results: reranked } = await rerank(query, documents, { topK: limit });
+    
+    const results = reranked.map(r => ({
+      text: searchResults[r.index].document.text,
+      score: r.relevanceScore,
+      metadata: searchResults[r.index].document.metadata,
+    }));
+{{else}}
+    const results = searchResults.map(r => ({
+      text: r.document.text,
+      score: r.score,
+      metadata: r.document.metadata,
+    }));
+{{/if}}
+    
+    const response = {
+      results,
+      meta: {
+        model: '{{model}}',
+{{#if rerank}}
+        rerankModel: '{{rerankModel}}',
+{{/if}}
+        took: Date.now() - start,
+      },
+    };
+    
+    if (includeContext) {
+      response.context = results.map(r => r.text).join('\n\n---\n\n');
+    }
+    
+    return NextResponse.json(response);
+  } catch (error) {
+    console.error('Search error:', error);
+    return NextResponse.json(
+      { error: error.message },
+      { status: 500 }
+    );
+  }
+}

package/src/lib/templates/nextjs/theme.js.tpl

@@ -0,0 +1,84 @@
+/**
+ * MUI Theme Configuration
+ * Generated by vai v{{vaiVersion}} on {{generatedAt}}
+ */
+
+'use client';
+
+import { createTheme } from '@mui/material/styles';
+
+// MongoDB-inspired color palette
+const palette = {
+  primary: {
+    main: '#00ED64',      // MongoDB Green
+    light: '#4DFF94',
+    dark: '#00B84A',
+    contrastText: '#000',
+  },
+  secondary: {
+    main: '#001E2B',      // MongoDB Dark
+    light: '#1C3A4B',
+    dark: '#000F17',
+    contrastText: '#fff',
+  },
+  background: {
+    default: '#FAFAFA',
+    paper: '#FFFFFF',
+  },
+  text: {
+    primary: '#001E2B',
+    secondary: '#5C6C75',
+  },
+};
+
+export const theme = createTheme({
+  palette,
+  typography: {
+    fontFamily: '"Inter", "Roboto", "Helvetica", "Arial", sans-serif',
+    h1: {
+      fontWeight: 700,
+    },
+    h2: {
+      fontWeight: 600,
+    },
+    h3: {
+      fontWeight: 600,
+    },
+    h4: {
+      fontWeight: 600,
+    },
+  },
+  shape: {
+    borderRadius: 8,
+  },
+  components: {
+    MuiButton: {
+      styleOverrides: {
+        root: {
+          textTransform: 'none',
+          fontWeight: 600,
+        },
+        contained: {
+          boxShadow: 'none',
+          '&:hover': {
+            boxShadow: 'none',
+          },
+        },
+      },
+    },
+    MuiCard: {
+      styleOverrides: {
+        root: {
+          boxShadow: '0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.06)',
+        },
+      },
+    },
+    MuiChip: {
+      styleOverrides: {
+        root: {
+          fontWeight: 500,
+        },
+      },
+    },
+  },
+});

package/src/lib/templates/python/README.md.tpl

@@ -0,0 +1,145 @@
+# {{projectName}}
+
+A semantic search API powered by Voyage AI embeddings and MongoDB Atlas Vector Search.
+
+## Configuration
+
+| Setting | Value |
+|---------|-------|
+| Embedding Model | `{{model}}` |
+| Dimensions | {{dimensions}} |
+| Database | `{{db}}` |
+| Collection | `{{collection}}` |
+| Vector Index | `{{index}}` |
+{{#if rerank}}
+| Rerank Model | `{{rerankModel}}` |
+{{/if}}
+
+## Setup
+
+### 1. Create virtual environment
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+### 2. Install dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Configure environment
+
+Copy `.env.example` to `.env` and fill in your credentials:
+
+```bash
+cp .env.example .env
+```
+
+Required variables:
+- `VOYAGE_API_KEY` - Your Voyage AI API key from [dash.voyageai.com](https://dash.voyageai.com)
+- `MONGODB_URI` - Your MongoDB Atlas connection string
+
+### 4. Create vector index
+
+In MongoDB Atlas, create a vector search index on your collection:
+
+```json
+{
+  "fields": [
+    {
+      "type": "vector",
+      "path": "{{field}}",
+      "numDimensions": {{dimensions}},
+      "similarity": "cosine"
+    }
+  ]
+}
+```
+
+Name the index `{{index}}`.
+
+### 5. Start the server
+
+```bash
+python app.py
+
+# For production
+gunicorn -w 4 -b 0.0.0.0:3000 app:app
+```
+
+## API Endpoints
+
+### POST /api/search
+
+Search for relevant documents.
+
+```bash
+curl -X POST http://localhost:3000/api/search \
+  -H "Content-Type: application/json" \
+  -d '{"query": "How does vector search work?", "limit": 5}'
+```
+
+Response:
+```json
+{
+  "results": [
+    {
+      "text": "Vector search uses...",
+      "score": 0.95,
+      "metadata": {"source": "docs/guide.md"}
+    }
+  ],
+  "meta": {
+    "model": "{{model}}",
+    "took": 123
+  }
+}
+```
+
+### POST /api/ingest
+
+Ingest text documents.
+
+```bash
+curl -X POST http://localhost:3000/api/ingest \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Your document content...", "metadata": {"source": "api"}}'
+```
+
+### GET /api/health
+
+Check API health and database connection.
+
+```bash
+curl http://localhost:3000/api/health
+```
+
+## Project Structure
+
+```
+{{projectName}}/
+├── app.py              # Flask application
+├── voyage_client.py    # Voyage AI API client
+├── mongo_client.py     # MongoDB connection helper
+├── chunker.py          # Text chunking utilities
+├── requirements.txt
+├── .env.example
+└── README.md
+```
+
+## Chunking Configuration
+
+Documents are chunked with the following settings:
+
+| Setting | Value |
+|---------|-------|
+| Strategy | `{{chunkStrategy}}` |
+| Chunk Size | {{chunkSize}} characters |
+| Overlap | {{chunkOverlap}} characters |
+
+---
+
+Generated by [vai](https://github.com/mrlynn/voyageai-cli) v{{vaiVersion}}

package/src/lib/templates/python/app.py.tpl

@@ -0,0 +1,221 @@
+"""
+Voyage AI RAG API (Flask)
+Generated by vai v{{vaiVersion}} on {{generatedAt}}
+
+Endpoints:
+- POST /api/search  - Semantic search with optional reranking
+- POST /api/ingest  - Document ingestion
+- GET  /api/health  - Health check
+"""
+
+import os
+import time
+from flask import Flask, request, jsonify
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from voyage_client import embed_query{{#if rerank}}, rerank{{/if}}
+from mongo_client import connect, vector_search, insert_documents, close
+from chunker import chunk_text
+
+app = Flask(__name__)
+
+
+@app.route("/")
+def index():
+    """API information."""
+    return jsonify({
+        "name": "{{projectName}}",
+        "description": "Voyage AI RAG API",
+        "model": "{{model}}",
+        "database": "{{db}}",
+        "collection": "{{collection}}",
+        "endpoints": {
+            "search": "POST /api/search",
+            "ingest": "POST /api/ingest",
+            "health": "GET /api/health",
+        },
+    })
+
+
+@app.route("/api/search", methods=["POST"])
+def search():
+    """
+    Semantic search endpoint.
+    
+    Request body:
+    {
+        "query": "What is vector search?",
+        "limit": 5,
+        "include_context": true
+    }
+    """
+    start = time.time()
+    data = request.get_json()
+    
+    query = data.get("query")
+    if not query:
+        return jsonify({"error": "Query is required"}), 400
+    
+    limit = data.get("limit", 5)
+{{#if rerank}}
+    candidates = data.get("candidates", 20)
+{{/if}}
+    include_context = data.get("include_context", False)
+    filter_query = data.get("filter")
+    
+    # Step 1: Embed the query
+    query_embedding = embed_query(query)
+    
+    # Step 2: Vector search
+{{#if rerank}}
+    search_results = vector_search(query_embedding, limit=candidates, filter_query=filter_query)
+{{else}}
+    search_results = vector_search(query_embedding, limit=limit, filter_query=filter_query)
+{{/if}}
+    
+    if not search_results:
+        return jsonify({
+            "results": [],
+            "meta": {"model": "{{model}}", "took": int((time.time() - start) * 1000)},
+        })
+    
+{{#if rerank}}
+    # Step 3: Rerank for better relevance
+    documents = [r["document"]["text"] for r in search_results]
+    rerank_result = rerank(query, documents, top_k=limit)
+    
+    results = [
+        {
+            "text": search_results[r["index"]]["document"]["text"],
+            "score": r["relevance_score"],
+            "metadata": search_results[r["index"]]["document"].get("metadata", {}),
+        }
+        for r in rerank_result["results"]
+    ]
+{{else}}
+    results = [
+        {
+            "text": r["document"]["text"],
+            "score": r["score"],
+            "metadata": r["document"].get("metadata", {}),
+        }
+        for r in search_results
+    ]
+{{/if}}
+    
+    response = {
+        "results": results,
+        "meta": {
+            "model": "{{model}}",
+{{#if rerank}}
+            "rerank_model": "{{rerankModel}}",
+{{/if}}
+            "took": int((time.time() - start) * 1000),
+        },
+    }
+    
+    if include_context:
+        response["context"] = "\n\n---\n\n".join(r["text"] for r in results)
+    
+    return jsonify(response)
+
+
+@app.route("/api/ingest", methods=["POST"])
+def ingest():
+    """
+    Document ingestion endpoint.
+    
+    Request body:
+    {
+        "text": "Document content...",
+        "metadata": {"source": "api"}
+    }
+    """
+    start = time.time()
+    data = request.get_json()
+    
+    text = data.get("text")
+    if not text:
+        return jsonify({"error": "Text is required"}), 400
+    
+    metadata = data.get("metadata", {})
+    metadata["source"] = metadata.get("source", "api")
+    
+    # Chunk the text
+    chunks = chunk_text(text)
+    
+    # Embed all chunks
+    from voyage_client import embed
+    result = embed(chunks, input_type="document")
+    embeddings = result["embeddings"]
+    
+    # Prepare documents
+    documents = [
+        {
+            "text": chunk,
+            "embedding": embeddings[i],
+            "metadata": {
+                **metadata,
+                "chunk_index": i,
+                "total_chunks": len(chunks),
+            },
+        }
+        for i, chunk in enumerate(chunks)
+    ]
+    
+    # Insert into MongoDB
+    insert_result = insert_documents(documents)
+    
+    return jsonify({
+        "success": True,
+        "chunks": len(chunks),
+        "tokens": result["usage"]["total_tokens"],
+        "took": int((time.time() - start) * 1000),
+    })
+
+
+@app.route("/api/health", methods=["GET"])
+def health():
+    """Health check endpoint."""
+    try:
+        connect()
+        return jsonify({
+            "status": "healthy",
+            "model": "{{model}}",
+            "database": "{{db}}",
+            "collection": "{{collection}}",
+        })
+    except Exception as e:
+        return jsonify({
+            "status": "unhealthy",
+            "error": str(e),
+        }), 503
+
+
+@app.teardown_appcontext
+def shutdown(exception=None):
+    """Clean up on shutdown."""
+    pass  # Connection pooling handles this
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 3000))
+    print(f"""
+🚀 Voyage AI RAG Server (Flask)
+
+   Model:      {{model}}
+   Database:   {{db}}.{{collection}}
+{{#if rerank}}
+   Reranking:  {{rerankModel}}
+{{/if}}
+
+   Endpoints:
+   POST /api/search  - Semantic search
+   POST /api/ingest  - Document ingestion
+   GET  /api/health  - Health check
+
+   Running on http://localhost:{port}
+""")
+    app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_DEBUG", "0") == "1")

package/src/lib/templates/python/chunker.py.tpl

@@ -0,0 +1,127 @@
+"""
+Text Chunker
+Generated by vai v{{vaiVersion}} on {{generatedAt}}
+
+Strategy: {{chunkStrategy}}
+Size: {{chunkSize}} characters
+Overlap: {{chunkOverlap}} characters
+"""
+
+from typing import List
+
+
+def chunk_text(
+    text: str,
+    size: int = {{chunkSize}},
+    overlap: int = {{chunkOverlap}},
+) -> List[str]:
+    """
+    Chunk text using recursive splitting with smart boundaries.
+    
+    Args:
+        text: Text to chunk
+        size: Maximum chunk size in characters
+        overlap: Overlap between chunks
+        
+    Returns:
+        List of text chunks
+    """
+    separators = ["\n\n", "\n", ". ", " "]
+    
+    def split_recursive(text: str, sep_index: int = 0) -> List[str]:
+        if len(text) <= size:
+            stripped = text.strip()
+            return [stripped] if stripped else []
+        
+        if sep_index >= len(separators):
+            # Fall back to fixed-size split
+            chunks = []
+            start = 0
+            while start < len(text):
+                chunk = text[start:start + size].strip()
+                if chunk:
+                    chunks.append(chunk)
+                start += size - overlap
+            return chunks
+        
+        separator = separators[sep_index]
+        parts = text.split(separator)
+        chunks = []
+        current = ""
+        
+        for part in parts:
+            potential = f"{current}{separator}{part}" if current else part
+            
+            if len(potential) <= size:
+                current = potential
+            else:
+                if current:
+                    chunks.extend(split_recursive(current, sep_index + 1))
+                current = part
+        
+        if current:
+            chunks.extend(split_recursive(current, sep_index + 1))
+        
+        return chunks
+    
+    return split_recursive(text)
+
+
+def chunk_markdown(text: str, size: int = {{chunkSize}}, overlap: int = {{chunkOverlap}}) -> List[str]:
+    """
+    Chunk markdown with header awareness.
+    Tries to keep sections together when possible.
+    """
+    import re
+    
+    # Split by headers (## or ###)
+    header_pattern = r"(^#{1,3}\s+.+$)"
+    parts = re.split(header_pattern, text, flags=re.MULTILINE)
+    
+    chunks = []
+    current = ""
+    
+    for part in parts:
+        if not part.strip():
+            continue
+        
+        potential = f"{current}\n\n{part}" if current else part
+        
+        if len(potential) <= size:
+            current = potential
+        else:
+            if current:
+                # Chunk the current section
+                chunks.extend(chunk_text(current, size, overlap))
+            current = part
+    
+    if current:
+        chunks.extend(chunk_text(current, size, overlap))
+    
+    return chunks
+
+
+if __name__ == "__main__":
+    # Test chunking
+    sample = """
+    # Introduction
+    
+    This is a sample document for testing the chunker.
+    It contains multiple paragraphs and sections.
+    
+    ## Section 1
+    
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+    Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+    
+    ## Section 2
+    
+    Ut enim ad minim veniam, quis nostrud exercitation ullamco.
+    Duis aute irure dolor in reprehenderit in voluptate velit.
+    """
+    
+    chunks = chunk_text(sample)
+    print(f"Created {len(chunks)} chunks:")
+    for i, chunk in enumerate(chunks):
+        print(f"\n--- Chunk {i + 1} ({len(chunk)} chars) ---")
+        print(chunk[:200] + "..." if len(chunk) > 200 else chunk)

package/src/lib/templates/python/env.example.tpl

@@ -0,0 +1,12 @@
+# Voyage AI API
+VOYAGE_API_KEY=your_voyage_api_key_here
+
+# MongoDB Atlas
+MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/{{db}}?retryWrites=true&w=majority
+
+# Server
+PORT=3000
+FLASK_DEBUG=0
+
+# Optional: Override defaults
+# VOYAGE_API_URL=https://api.voyageai.com/v1