Upload folder using huggingface_hub

.gitattributes

@@ -67,3 +67,5 @@ proteins_below_4096bp.fasta filter=lfs diff=lfs merge=lfs -text
 repeats_results_full.csv filter=lfs diff=lfs merge=lfs -text
 bpe_plus_special_tokens_tokenizer.json filter=lfs diff=lfs merge=lfs -text
 faiss.index filter=lfs diff=lfs merge=lfs -text
+data/data/bpe_plus_special_tokens_tokenizer.json filter=lfs diff=lfs merge=lfs -text
+data/data/faiss.index filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,177 @@
+# Semantic Search API
+
+A production-ready semantic search service built with FastAPI. Upload your data (sequences + metadata), create embeddings automatically, and search using natural language queries.
+
+## Features
+
+- **Semantic/Latent Search**: Find similar sequences based on meaning, not just keywords
+- **FastAPI Backend**: Modern, fast, async Python web framework
+- **FAISS Index**: Efficient similarity search at scale
+- **Sentence Transformers**: State-of-the-art embedding models
+- **Beautiful UI**: Dark-themed, responsive search interface
+- **CSV Upload**: Easy data import via web interface or API
+- **Persistent Storage**: Index persists across restarts
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Run the Server
+
+```bash
+python app.py
+# or
+uvicorn app:app --reload --host 0.0.0.0 --port 8000
+```
+
+### 3. Open the UI
+
+Navigate to `http://localhost:8000` in your browser.
+
+### 4. Upload Your Data
+
+- Drag & drop a CSV file or click to browse
+- Select the column containing your sequences
+- Click "Create Index"
+- Start searching!
+
+## Data Format
+
+Your CSV should have at least one column containing the text sequences you want to search. All other columns become searchable metadata.
+
+Example:
+```csv
+sequence,category,source,date
+"Machine learning is transforming industries",tech,blog,2024-01-15
+"The quick brown fox jumps over the lazy dog",example,pangram,2024-01-10
+"Embeddings capture semantic meaning",ml,paper,2024-01-20
+```
+
+## API Endpoints
+
+### Search
+```bash
+POST /api/search
+Content-Type: application/json
+
+{
+  "query": "artificial intelligence",
+  "top_k": 10
+}
+```
+
+### Upload CSV
+```bash
+POST /api/upload-csv?sequence_column=text
+Content-Type: multipart/form-data
+
+file: your_data.csv
+```
+
+### Create Index (JSON)
+```bash
+POST /api/index
+Content-Type: application/json
+
+{
+  "sequence_column": "text",
+  "data": [
+    {"text": "Hello world", "category": "greeting"},
+    {"text": "Machine learning", "category": "tech"}
+  ]
+}
+```
+
+### Get Stats
+```bash
+GET /api/stats
+```
+
+### Get Sample
+```bash
+GET /api/sample?n=5
+```
+
+### Delete Index
+```bash
+DELETE /api/index
+```
+
+## Programmatic Usage
+
+You can also create indexes directly from Python:
+
+```python
+from create_index import create_index_from_dataframe, search_index
+import pandas as pd
+
+# Create your dataframe
+df = pd.DataFrame({
+    'sequence': [
+        'The mitochondria is the powerhouse of the cell',
+        'DNA stores genetic information',
+        'Proteins are made of amino acids'
+    ],
+    'category': ['biology', 'genetics', 'biochemistry'],
+    'difficulty': ['easy', 'medium', 'medium']
+})
+
+# Create the index
+create_index_from_dataframe(df, sequence_column='sequence')
+
+# Search
+results = search_index("cellular energy production", top_k=3)
+for r in results:
+    print(f"Score: {r['score']:.3f} | {r['sequence'][:50]}...")
+```
+
+## Configuration
+
+Edit these values in `app.py` to customize:
+
+```python
+# Embedding model (from sentence-transformers)
+EMBEDDING_MODEL = "all-MiniLM-L6-v2"  # Fast, 384 dimensions
+
+# Alternatives:
+# "all-mpnet-base-v2"  # Higher quality, 768 dimensions
+# "paraphrase-multilingual-MiniLM-L12-v2"  # Multilingual support
+# "all-MiniLM-L12-v2"  # Balanced quality/speed
+```
+
+## Project Structure
+
+```
+semantic_search/
+├── app.py              # FastAPI application
+├── create_index.py     # Programmatic index creation
+├── requirements.txt    # Python dependencies
+├── static/
+│   └── index.html      # Search UI
+├── data/               # Created at runtime
+│   ├── faiss.index     # FAISS index file
+│   ├── metadata.pkl    # DataFrame with metadata
+│   └── embeddings.npy  # Raw embeddings (optional)
+└── README.md
+```
+
+## How It Works
+
+1. **Embedding Creation**: When you upload data, each sequence is converted to a dense vector (embedding) using a sentence transformer model
+2. **FAISS Indexing**: Embeddings are stored in a FAISS index optimized for similarity search
+3. **Search**: Your query is embedded using the same model, then FAISS finds the most similar vectors using cosine similarity
+4. **Results**: The original sequences and metadata are returned, ranked by similarity
+
+## Performance Tips
+
+- **Model Choice**: `all-MiniLM-L6-v2` is fast and good for most use cases. Use `all-mpnet-base-v2` for higher quality at the cost of speed.
+- **Batch Size**: For large datasets, the model processes in batches automatically
+- **GPU**: If you have a CUDA-capable GPU, install `faiss-gpu` instead of `faiss-cpu` for faster indexing
+
+## License
+
+MIT

app.py

@@ -0,0 +1,267 @@
+"""
+Genomic Semantic Search API with FastAPI
+=========================================
+Search genomic sequences using your pre-trained transformer embeddings.
+"""
+
+import pickle
+from pathlib import Path
+from typing import Optional
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import faiss
+import torch
+import torch.nn as nn
+from x_transformers import TransformerWrapper, Encoder
+import tiktoken
+
+# ============================================================================
+# Configuration
+# ============================================================================
+
+DATA_DIR = Path("data")
+INDEX_PATH = DATA_DIR / "data/faiss.index"
+METADATA_PATH = DATA_DIR / "data/metadata.pkl"
+EMBEDDINGS_PATH = DATA_DIR / "data/embeddings.npy"
+
+# Model paths - update these to your actual paths
+MODEL_WEIGHTS_PATH = DATA_DIR / "data/bpe_plus_special_tokens_model.pt"
+TOKENIZER_PATH = DATA_DIR / "data/bpe_plus_special_tokens_tokenizer.json"
+
+# ============================================================================
+# Model Definition
+# ============================================================================
+
+class GenomicTransformer(nn.Module):
+    def __init__(self, vocab_size=40000, hidden_dim=512, layers=12, heads=8, max_length=6000):
+        super().__init__()
+        self.model = TransformerWrapper(
+            num_tokens=vocab_size,
+            max_seq_len=max_length,
+            attn_layers=Encoder(
+                dim=hidden_dim,
+                depth=layers,
+                heads=heads,
+                rotary_pos_emb=True,
+                attn_orthog_projected_values=True,
+                attn_orthog_projected_values_per_head=True,
+                attn_flash=True
+            )
+        )
+
+    def forward(self, input_ids, return_embeddings=False):
+        return self.model(input_ids, return_embeddings=return_embeddings)
+
+# ============================================================================
+# App Setup
+# ============================================================================
+
+app = FastAPI(
+    title="Genomic Semantic Search",
+    description="Search genomic sequences using transformer embeddings",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global state
+device: torch.device = None
+model: Optional[GenomicTransformer] = None
+encoder: Optional[tiktoken.Encoding] = None
+index: Optional[faiss.IndexFlatIP] = None
+metadata: Optional[pd.DataFrame] = None
+
+# ============================================================================
+# Models
+# ============================================================================
+
+class SearchRequest(BaseModel):
+    query: str  # The genomic sequence to search for
+    top_k: int = 10
+
+class SearchResult(BaseModel):
+    rank: int
+    score: float
+    sequence: str
+    metadata: dict
+
+class SearchResponse(BaseModel):
+    query: str
+    results: list[SearchResult]
+    total_indexed: int
+
+class IndexStats(BaseModel):
+    total_documents: int
+    embedding_dimension: int
+    model_name: str
+    device: str
+
+# ============================================================================
+# Startup
+# ============================================================================
+
+@app.on_event("startup")
+async def startup():
+    """Load the model, tokenizer, and FAISS index on startup."""
+    global device, model, encoder, index, metadata
+
+    # Setup device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load tokenizer
+    print("Loading tokenizer...")
+    if TOKENIZER_PATH.exists():
+        with open(TOKENIZER_PATH, "rb") as f:
+            tokenizer_data = pickle.load(f)
+        encoder = tiktoken.Encoding(
+            name="genomic_bpe",
+            pat_str=tokenizer_data['pattern'],
+            mergeable_ranks=tokenizer_data['mergable_ranks'],
+            special_tokens={}
+        )
+        print("Tokenizer loaded successfully")
+    else:
+        print(f"WARNING: Tokenizer not found at {TOKENIZER_PATH}")
+
+    # Load model
+    print("Loading model...")
+    if MODEL_WEIGHTS_PATH.exists():
+        model = GenomicTransformer(
+            vocab_size=40_000, hidden_dim=512, layers=12, heads=8
+        )
+        weights = torch.load(MODEL_WEIGHTS_PATH, map_location=device)
+        model.load_state_dict(weights)
+        model = model.to(device)
+        model.eval()
+        print("Model loaded successfully")
+    else:
+        print(f"WARNING: Model weights not found at {MODEL_WEIGHTS_PATH}")
+
+    # Load FAISS index
+    if INDEX_PATH.exists() and METADATA_PATH.exists():
+        print("Loading FAISS index...")
+        index = faiss.read_index(str(INDEX_PATH))
+        with open(METADATA_PATH, "rb") as f:
+            metadata = pickle.load(f)
+        print(f"Index loaded with {index.ntotal} documents")
+    else:
+        print(f"WARNING: Index not found at {INDEX_PATH}")
+
+# ============================================================================
+# API Endpoints
+# ============================================================================
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Serve the search frontend."""
+    return FileResponse("index.html")
+
+@app.get("/api/health")
+async def health():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "index_loaded": index is not None,
+        "tokenizer_loaded": encoder is not None,
+        "device": str(device)
+    }
+
+@app.get("/api/stats", response_model=IndexStats)
+async def get_stats():
+    """Get statistics about the current index."""
+    if index is None:
+        raise HTTPException(status_code=404, detail="No index loaded")
+
+    return IndexStats(
+        total_documents=index.ntotal,
+        embedding_dimension=index.d,
+        model_name="GenomicTransformer (512d, 12 layers)",
+        device=str(device)
+    )
+
+@app.post("/api/search", response_model=SearchResponse)
+async def search(request: SearchRequest):
+    """
+    Perform semantic search over genomic sequences.
+
+    - **query**: The genomic sequence to search for (e.g., "ATCGATCG...")
+    - **top_k**: Number of results to return (default: 10)
+    """
+    if index is None or metadata is None:
+        raise HTTPException(status_code=404, detail="No index loaded")
+    if model is None or encoder is None:
+        raise HTTPException(status_code=503, detail="Model or tokenizer not loaded")
+    if index.ntotal == 0:
+        raise HTTPException(status_code=404, detail="Index is empty")
+
+    # Encode the query sequence
+    try:
+        encodings = encoder.encode_ordinary(request.query)
+        query_tensor = torch.tensor([encodings]).long().to(device)
+
+        with torch.no_grad():
+            query_embedding = model(query_tensor, return_embeddings=True)
+            query_embedding = query_embedding.mean(dim=1).cpu().numpy()
+
+        query_embedding = query_embedding.astype(np.float32)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to encode query: {str(e)}")
+
+    # Search
+    k = min(request.top_k, index.ntotal)
+    scores, indices = index.search(query_embedding, k)
+
+    # Build results
+    results = []
+    for rank, (score, idx) in enumerate(zip(scores[0], indices[0]), 1):
+        if idx == -1:
+            continue
+
+        row = metadata.iloc[idx]
+        meta_dict = row.to_dict()
+        sequence = meta_dict.pop("__sequence__", "")
+
+        results.append(SearchResult(
+            rank=rank,
+            score=float(score),
+            sequence=sequence,
+            metadata=meta_dict
+        ))
+
+    return SearchResponse(
+        query=request.query[:100] + "..." if len(request.query) > 100 else request.query,
+        results=results,
+        total_indexed=index.ntotal
+    )
+
+@app.get("/api/sample")
+async def get_sample(n: int = 5):
+    """Get a sample of indexed documents."""
+    if metadata is None:
+        raise HTTPException(status_code=404, detail="No index loaded")
+
+    sample = metadata.head(n)
+    return {
+        "total": len(metadata),
+        "sample": sample.to_dict(orient="records")
+    }
+
+# Mount  files
+# app.mount("/static", StaticFiles(directory="static"), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8080)

create_index.py

@@ -0,0 +1,254 @@
+"""
+Programmatic Index Creation
+===========================
+Use this script to create an index from a DataFrame without the web interface.
+
+Example usage:
+    python create_index.py --input data.csv --sequence-column text
+    
+Or use programmatically:
+    from create_index import create_index_from_dataframe
+    import pandas as pd
+    
+    df = pd.DataFrame({
+        'sequence': ['Hello world', 'Machine learning is great', ...],
+        'category': ['greeting', 'tech', ...],
+        'id': [1, 2, ...]
+    })
+    
+    create_index_from_dataframe(df, sequence_column='sequence')
+"""
+
+import argparse
+import pickle
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from pickle import dump, load
+import tiktoken
+import faiss
+import torch.nn as nn
+from x_transformers import TransformerWrapper, Encoder
+import torch
+from tqdm import tqdm
+
+# Set device and check available GPUs
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+n_gpus = torch.cuda.device_count()
+print(f"Using device: {device}")
+print(f"Available GPUs: {n_gpus}")
+for i in range(n_gpus):
+    print(f"  GPU {i}: {torch.cuda.get_device_name(i)}")
+
+
+class GenomicTransformer(nn.Module):
+    def __init__(self, vocab_size=40000, hidden_dim=32, layers=2, heads=3, max_length=6000):
+        super().__init__()
+        self.model = TransformerWrapper(
+            num_tokens=vocab_size,
+            max_seq_len=max_length,
+            attn_layers=Encoder(
+                dim=hidden_dim,
+                depth=layers,
+                heads=heads,
+                rotary_pos_emb=True,
+                attn_orthog_projected_values=True,
+                attn_orthog_projected_values_per_head=True, 
+                attn_flash=True
+            )
+        )
+        
+    def forward(self, input_ids, return_embeddings=False):
+        logits = self.model(input_ids, return_embeddings=return_embeddings)
+        return logits
+
+
+# Configuration - must match app.py
+DATA_DIR = Path("data")
+DATA_DIR.mkdir(exist_ok=True)
+INDEX_PATH = DATA_DIR / "faiss.index"
+METADATA_PATH = DATA_DIR / "metadata.pkl"
+EMBEDDINGS_PATH = DATA_DIR / "embeddings.npy"
+EMBEDDING_MODEL = "all-MiniLM-L6-v2"
+
+pattern = load(open("/user/hassanahmed.hassan/u21055/.project/dir.project/towards_better_genomic_models/data/tokenizer_components_bpe_with_repeats.pkl", "rb"))['pattern']
+mergable_ranks = load(open("/user/hassanahmed.hassan/u21055/.project/dir.project/towards_better_genomic_models/data/tokenizer_components_bpe_with_repeats.pkl", "rb"))['mergable_ranks']
+
+recreated_enc = tiktoken.Encoding(
+    name="genomic_bpe_recreated",
+    pat_str=pattern,
+    mergeable_ranks=mergable_ranks,
+    special_tokens={}
+)
+
+# Initialize model
+MODEL = GenomicTransformer(
+    vocab_size=40_000, hidden_dim=512, layers=12, heads=8
+)
+
+# Wrap with DataParallel if multiple GPUs available
+if n_gpus > 1:
+    print(f"Using DataParallel across {n_gpus} GPUs")
+    MODEL = nn.DataParallel(MODEL)
+
+MODEL = MODEL.to(device)
+MODEL.eval()
+
+
+def create_index_from_dataframe(
+    df: pd.DataFrame,
+    sequence_column: str = "sequence",
+    model=MODEL,
+    encoder=recreated_enc,
+    batch_size: int = 8  # Increased batch size for multi-GPU
+) -> dict:
+    """
+    Create a FAISS index from a pandas DataFrame.
+    
+    Args:
+        df: DataFrame containing sequences and metadata
+        sequence_column: Name of the column containing text sequences
+        model: The transformer model to use
+        encoder: The tokenizer/encoder
+        batch_size: Batch size for encoding (increase for multi-GPU)
+        
+    Returns:
+        dict with index statistics
+    """
+    if sequence_column not in df.columns:
+        raise ValueError(f"Column '{sequence_column}' not found. Available: {list(df.columns)}")
+    
+    # Get sequences
+    sequences = df[sequence_column].astype(str).tolist()[:10]
+    df = df.iloc[:10].copy()
+    df["__sequence__"] = sequences
+    
+    # Create embeddings
+    print(f"Creating embeddings for {len(sequences)} sequences...")
+    encodings = encoder.encode_batch(sequences)
+    embeddings = []
+    print(f"Total encodings: {len(encodings)}")
+    
+    # Adjust batch size to be divisible by number of GPUs for efficiency
+    effective_batch_size = batch_size * n_gpus if n_gpus > 1 else batch_size
+    print(f"Using effective batch size: {effective_batch_size}")
+    
+    for i in tqdm(range(0, len(encodings), effective_batch_size)):
+        batch_encodings = encodings[i:i+effective_batch_size]
+        # pad to max length in batch
+        max_len = max(len(enc) for enc in batch_encodings)
+        batch_encodings = [enc + [0]*(max_len - len(enc)) for enc in batch_encodings]
+        
+        # Move tensor to GPU
+        batch_tensor = torch.tensor(batch_encodings).long().to(device)
+        print(f"Batch tensor shape: {batch_tensor.shape}")
+        print(f"Sample batch tensor: {batch_tensor[0][:10]}")
+        
+        with torch.no_grad():
+            print("Generating embeddings...")
+            batch_embeddings = model(batch_tensor, return_embeddings=True)
+            print(f"Raw batch embeddings shape: {batch_embeddings.shape}")
+            # Move back to CPU for numpy conversion
+            batch_embeddings = batch_embeddings.mean(dim=1).cpu().numpy().tolist()
+            print(f"Batch embeddings shape: {np.array(batch_embeddings).shape}")
+
+        if i == 0:
+            embeddings = batch_embeddings
+        else:
+            embeddings = embeddings + batch_embeddings
+
+    embeddings = np.array(embeddings)
+    embeddings = embeddings.astype(np.float32)
+    
+    # Create FAISS index
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatIP(dimension)  # Inner product = cosine sim for normalized vectors
+    index.add(embeddings)
+    
+    # Save everything
+    print("Saving index to disk...")
+    faiss.write_index(index, str(INDEX_PATH))
+    with open(METADATA_PATH, "wb") as f:
+        pickle.dump(df, f)
+    np.save(EMBEDDINGS_PATH, embeddings)
+    
+    stats = {
+        "documents_indexed": index.ntotal,
+        "embedding_dimension": dimension,
+        "model": 'MODEL',
+        "index_path": str(INDEX_PATH),
+        "metadata_path": str(METADATA_PATH),
+        "gpus_used": n_gpus
+    }
+    
+    print(f"Index created successfully!")
+    print(f"  - Documents: {stats['documents_indexed']}")
+    print(f"  - Dimensions: {stats['embedding_dimension']}")
+    print(f"  - GPUs used: {stats['gpus_used']}")
+    
+    return stats
+
+
+def search_index(
+    query: str,
+    top_k: int = 10,
+    model=MODEL, 
+    encoder=recreated_enc
+) -> list[dict]:
+    """
+    Search the index for similar sequences.
+    """
+    if not INDEX_PATH.exists():
+        raise FileNotFoundError("No index found. Create one first with create_index_from_dataframe()")
+    
+    # Load resources
+    index = faiss.read_index(str(INDEX_PATH))
+    with open(METADATA_PATH, "rb") as f:
+        metadata = pickle.load(f)
+    
+    # Encode query
+    encodings = encoder.encode_ordinary(query)
+    query_tensor = torch.tensor([encodings]).long().to(device)
+    
+    with torch.no_grad():
+        query_embedding = model(query_tensor, return_embeddings=True).mean(dim=1).cpu().numpy()
+    
+    query_embedding = query_embedding.astype(np.float32)
+    
+    # Search
+    k = min(top_k, index.ntotal)
+    scores, indices = index.search(query_embedding, k)
+    
+    # Build results
+    results = []
+    for score, idx in zip(scores[0], indices[0]):
+        if idx == -1:
+            continue
+        
+        row = metadata.iloc[idx].to_dict()
+        sequence = row.pop("__sequence__", "")
+        
+        results.append({
+            "score": float(score),
+            "sequence": sequence,
+            "metadata": row
+        })
+    
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Create semantic search index from CSV")
+    parser.add_argument("--sequence-column", "-c", default="seq_with_repeat_tokens", help="Column containing sequences")
+    parser.add_argument("--batch-size", "-b", type=int, default=8, help="Batch size per GPU")
+    
+    args = parser.parse_args()
+    
+    df = pd.read_parquet("/user/hassanahmed.hassan/u21055/.project/dir.project/towards_better_genomic_models/data/sample.parquet")
+    print(f"Loaded {len(df)} rows with columns: {list(df.columns)}")
+    
+    create_index_from_dataframe(df, args.sequence_column, MODEL, recreated_enc, batch_size=args.batch_size)
+
+
+if __name__ == "__main__":
+    main()

data/data/bpe_plus_special_tokens_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2811ae2bb5890b033f326622ded51fca54461016389ea06578760418b3df14de
+size 327656691

data/data/bpe_plus_special_tokens_tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b01b9201adfc0892e867bb5ece10d7c83bc1c740f595d0452008288905fcb4d
+size 842903

data/data/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:134f630a923a588597432a3297ad2bb099becb7ab631b6ab30de9dc120389a79
+size 204800128

data/data/faiss.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e7aa815134b8aa8715c63505d3d2e34681aadd748e81d764939d61c3589625f
+size 204800045

data/data/metadata.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09e1530cca7fd6c444fa8486a0671656cf9dd37408a10fd7dc6cf8d86dcf97cf
+size 1069945904

data/data/repeats_results_small.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5c6cfa93298110b4d72bedbca1fce0848a0937fde8ed72acef3d6ad8abbb58b
+size 155282

data/data/sample_small.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc0d45175022214d02fe8d671a8cdf70f72d7bf45b5d5993af2b8696cb0a97d2
+size 4869635

index.html

@@ -0,0 +1,704 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Genomic Sequence Search</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Outfit:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg-primary: #0a0a0b;
+            --bg-secondary: #111113;
+            --bg-tertiary: #18181b;
+            --bg-hover: #1f1f23;
+            --border: #27272a;
+            --border-focus: #3f3f46;
+            --text-primary: #fafafa;
+            --text-secondary: #a1a1aa;
+            --text-muted: #71717a;
+            --accent: #10b981;
+            --accent-dim: #059669;
+            --accent-glow: rgba(16, 185, 129, 0.15);
+            --dna-a: #22d3ee;
+            --dna-t: #f472b6;
+            --dna-c: #a78bfa;
+            --dna-g: #fbbf24;
+            --success: #4ade80;
+            --error: #f87171;
+            --gradient-1: linear-gradient(135deg, #10b981 0%, #22d3ee 100%);
+            --radius-sm: 6px;
+            --radius-md: 10px;
+            --radius-lg: 16px;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Outfit', -apple-system, BlinkMacSystemFont, sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            min-height: 100vh;
+            line-height: 1.6;
+        }
+
+        body::before {
+            content: '';
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background-image: 
+                linear-gradient(rgba(16, 185, 129, 0.03) 1px, transparent 1px),
+                linear-gradient(90deg, rgba(16, 185, 129, 0.03) 1px, transparent 1px);
+            background-size: 40px 40px;
+            pointer-events: none;
+            z-index: 0;
+        }
+
+        .container {
+            max-width: 1000px;
+            margin: 0 auto;
+            padding: 2rem;
+            position: relative;
+            z-index: 1;
+        }
+
+        header {
+            text-align: center;
+            padding: 2rem 0 1.5rem;
+        }
+
+        .logo {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.75rem;
+            margin-bottom: 0.75rem;
+        }
+
+        .logo-icon {
+            width: 52px;
+            height: 52px;
+            background: var(--gradient-1);
+            border-radius: var(--radius-md);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.75rem;
+        }
+
+        h1 {
+            font-size: 2.25rem;
+            font-weight: 600;
+            letter-spacing: -0.03em;
+            background: var(--gradient-1);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+
+        .subtitle {
+            color: var(--text-secondary);
+            font-size: 1rem;
+            font-weight: 300;
+            margin-top: 0.25rem;
+        }
+
+        .stats-bar {
+            display: flex;
+            justify-content: center;
+            gap: 2.5rem;
+            padding: 1rem 0;
+            margin-bottom: 1.5rem;
+            border-bottom: 1px solid var(--border);
+        }
+
+        .stat {
+            text-align: center;
+        }
+
+        .stat-value {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 1.25rem;
+            font-weight: 500;
+            color: var(--accent);
+        }
+
+        .stat-label {
+            font-size: 0.7rem;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 0.08em;
+            margin-top: 0.2rem;
+        }
+
+        .search-section {
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 1.5rem;
+            margin-bottom: 1.5rem;
+        }
+
+        .search-label {
+            display: block;
+            font-size: 0.85rem;
+            font-weight: 500;
+            color: var(--text-secondary);
+            margin-bottom: 0.75rem;
+        }
+
+        .search-textarea {
+            width: 100%;
+            min-height: 120px;
+            padding: 1rem;
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.9rem;
+            background: var(--bg-primary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-md);
+            color: var(--text-primary);
+            resize: vertical;
+            transition: all 0.2s ease;
+            line-height: 1.6;
+        }
+
+        .search-textarea:focus {
+            outline: none;
+            border-color: var(--accent);
+            box-shadow: 0 0 0 3px var(--accent-glow);
+        }
+
+        .search-textarea::placeholder {
+            color: var(--text-muted);
+        }
+
+        .search-controls {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-top: 1rem;
+            gap: 1rem;
+        }
+
+        .char-count {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.8rem;
+            color: var(--text-muted);
+        }
+
+        .search-actions {
+            display: flex;
+            gap: 0.75rem;
+            align-items: center;
+        }
+
+        .top-k-select {
+            padding: 0.6rem 0.75rem;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-sm);
+            color: var(--text-primary);
+            font-family: inherit;
+            font-size: 0.85rem;
+            cursor: pointer;
+        }
+
+        .search-btn {
+            padding: 0.75rem 2rem;
+            background: var(--gradient-1);
+            border: none;
+            border-radius: var(--radius-md);
+            color: var(--bg-primary);
+            font-family: inherit;
+            font-size: 0.95rem;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .search-btn:hover {
+            opacity: 0.9;
+            transform: scale(1.02);
+        }
+
+        .search-btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .clear-btn {
+            padding: 0.6rem 1rem;
+            background: transparent;
+            border: 1px solid var(--border);
+            border-radius: var(--radius-sm);
+            color: var(--text-secondary);
+            font-family: inherit;
+            font-size: 0.85rem;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .clear-btn:hover {
+            border-color: var(--border-focus);
+            color: var(--text-primary);
+        }
+
+        .results-container {
+            margin-top: 1rem;
+        }
+
+        .results-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 1rem;
+            padding-bottom: 0.75rem;
+            border-bottom: 1px solid var(--border);
+        }
+
+        .results-count {
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+        }
+
+        .results-count strong {
+            color: var(--text-primary);
+        }
+
+        .result-card {
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-md);
+            padding: 1.25rem;
+            margin-bottom: 0.75rem;
+            transition: all 0.2s ease;
+            animation: slideIn 0.3s ease forwards;
+            opacity: 0;
+            transform: translateY(10px);
+        }
+
+        .result-card:hover {
+            border-color: var(--border-focus);
+            background: var(--bg-tertiary);
+        }
+
+        @keyframes slideIn {
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .result-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 0.75rem;
+        }
+
+        .result-rank {
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            width: 32px;
+            height: 32px;
+            background: var(--bg-primary);
+            border-radius: var(--radius-sm);
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.85rem;
+            font-weight: 600;
+            color: var(--text-secondary);
+        }
+
+        .result-rank.top-3 {
+            background: var(--accent-glow);
+            color: var(--accent);
+        }
+
+        .result-score {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.85rem;
+            color: var(--accent);
+            background: var(--accent-glow);
+            padding: 0.3rem 0.85rem;
+            border-radius: var(--radius-sm);
+        }
+
+        .result-sequence {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.85rem;
+            color: var(--text-primary);
+            background: var(--bg-primary);
+            padding: 0.85rem 1rem;
+            border-radius: var(--radius-sm);
+            margin-bottom: 0.75rem;
+            word-break: break-all;
+            line-height: 1.7;
+            max-height: 120px;
+            overflow-y: auto;
+            letter-spacing: 0.5px;
+        }
+
+        .result-metadata {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.5rem;
+        }
+
+        .metadata-tag {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.4rem;
+            padding: 0.35rem 0.75rem;
+            background: var(--bg-primary);
+            border-radius: var(--radius-sm);
+            font-size: 0.8rem;
+        }
+
+        .metadata-key {
+            color: var(--text-muted);
+        }
+
+        .metadata-value {
+            color: var(--text-secondary);
+            font-family: 'JetBrains Mono', monospace;
+            max-width: 200px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        .loading {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            gap: 1rem;
+            padding: 3rem;
+            color: var(--text-secondary);
+        }
+
+        .spinner {
+            width: 32px;
+            height: 32px;
+            border: 3px solid var(--border);
+            border-top-color: var(--accent);
+            border-radius: 50%;
+            animation: spin 0.8s linear infinite;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        .message {
+            padding: 1rem 1.25rem;
+            border-radius: var(--radius-md);
+            margin-bottom: 1rem;
+            font-size: 0.9rem;
+        }
+
+        .message.error {
+            background: rgba(248, 113, 113, 0.1);
+            border: 1px solid rgba(248, 113, 113, 0.2);
+            color: var(--error);
+        }
+
+        .message.info {
+            background: rgba(16, 185, 129, 0.1);
+            border: 1px solid rgba(16, 185, 129, 0.2);
+            color: var(--accent);
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 4rem 2rem;
+            color: var(--text-muted);
+        }
+
+        .empty-state-icon {
+            font-size: 3.5rem;
+            margin-bottom: 1rem;
+            opacity: 0.4;
+        }
+
+        .empty-state p {
+            font-size: 1rem;
+        }
+
+        .example-queries {
+            margin-top: 1.5rem;
+        }
+
+        .example-queries h4 {
+            font-size: 0.8rem;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            margin-bottom: 0.75rem;
+        }
+
+        .example-btn {
+            display: inline-block;
+            padding: 0.5rem 1rem;
+            margin: 0.25rem;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-sm);
+            color: var(--text-secondary);
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.75rem;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .example-btn:hover {
+            border-color: var(--accent);
+            color: var(--accent);
+        }
+
+        @media (max-width: 640px) {
+            .container {
+                padding: 1rem;
+            }
+
+            h1 {
+                font-size: 1.5rem;
+            }
+
+            .stats-bar {
+                gap: 1.5rem;
+            }
+
+            .search-controls {
+                flex-direction: column;
+                align-items: stretch;
+            }
+
+            .search-actions {
+                justify-content: space-between;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <div class="logo">
+                <div class="logo-icon">🧬</div>
+            </div>
+            <h1>Genomic Sequence Search</h1>
+            <p class="subtitle">Find similar sequences using transformer embeddings</p>
+        </header>
+
+        <div class="stats-bar">
+            <div class="stat">
+                <div class="stat-value" id="doc-count">—</div>
+                <div class="stat-label">Sequences</div>
+            </div>
+            <div class="stat">
+                <div class="stat-value" id="dim-count">—</div>
+                <div class="stat-label">Dimensions</div>
+            </div>
+            <div class="stat">
+                <div class="stat-value" id="device-info">—</div>
+                <div class="stat-label">Device</div>
+            </div>
+        </div>
+
+        <div id="message-container"></div>
+
+        <div class="search-section">
+            <label class="search-label">Enter a genomic sequence to search:</label>
+            <textarea 
+                class="search-textarea" 
+                id="search-input" 
+                placeholder="Paste your genomic sequence here (e.g., ATCGATCGATCG...)"
+                spellcheck="false"
+            ></textarea>
+            <div class="search-controls">
+                <span class="char-count"><span id="char-count">0</span> characters</span>
+                <div class="search-actions">
+                    <button class="clear-btn" onclick="clearSearch()">Clear</button>
+                    <select class="top-k-select" id="top-k">
+                        <option value="5">Top 5</option>
+                        <option value="10" selected>Top 10</option>
+                        <option value="20">Top 20</option>
+                        <option value="50">Top 50</option>
+                    </select>
+                    <button class="search-btn" id="search-btn" onclick="search()">
+                        Search
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <div class="results-container" id="results-container">
+            <div class="empty-state">
+                <div class="empty-state-icon">🔬</div>
+                <p>Enter a sequence above to find similar matches</p>
+                <div class="example-queries">
+                    <h4>Try an example</h4>
+                    <button class="example-btn" onclick="loadExample('ATCGATCGATCGATCGATCG')">ATCGATCG...</button>
+                    <button class="example-btn" onclick="loadExample('GCTAGCTAGCTAGCTAGCTA')">GCTAGCTA...</button>
+                    <button class="example-btn" onclick="loadExample('AAAATTTTCCCCGGGGAAAA')">AAAATTTT...</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const API_BASE = '';
+
+        document.addEventListener('DOMContentLoaded', () => {
+            loadStats();
+            
+            const input = document.getElementById('search-input');
+            input.addEventListener('input', updateCharCount);
+            input.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter' && e.ctrlKey) {
+                    search();
+                }
+            });
+        });
+
+        async function loadStats() {
+            try {
+                const res = await fetch(`${API_BASE}/api/stats`);
+                if (res.ok) {
+                    const data = await res.json();
+                    document.getElementById('doc-count').textContent = data.total_documents.toLocaleString();
+                    document.getElementById('dim-count').textContent = data.embedding_dimension;
+                    document.getElementById('device-info').textContent = data.device.toUpperCase();
+                }
+            } catch (e) {
+                console.log('Could not load stats:', e);
+            }
+        }
+
+        function updateCharCount() {
+            const count = document.getElementById('search-input').value.length;
+            document.getElementById('char-count').textContent = count.toLocaleString();
+        }
+
+        function clearSearch() {
+            document.getElementById('search-input').value = '';
+            updateCharCount();
+            document.getElementById('results-container').innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">🔬</div>
+                    <p>Enter a sequence above to find similar matches</p>
+                    <div class="example-queries">
+                        <h4>Try an example</h4>
+                        <button class="example-btn" onclick="loadExample('ATCGATCGATCGATCGATCG')">ATCGATCG...</button>
+                        <button class="example-btn" onclick="loadExample('GCTAGCTAGCTAGCTAGCTA')">GCTAGCTA...</button>
+                        <button class="example-btn" onclick="loadExample('AAAATTTTCCCCGGGGAAAA')">AAAATTTT...</button>
+                    </div>
+                </div>
+            `;
+        }
+
+        function loadExample(seq) {
+            document.getElementById('search-input').value = seq;
+            updateCharCount();
+            search();
+        }
+
+        async function search() {
+            const query = document.getElementById('search-input').value.trim();
+            if (!query) {
+                showMessage('Please enter a sequence to search', 'error');
+                return;
+            }
+
+            const topK = parseInt(document.getElementById('top-k').value);
+            const container = document.getElementById('results-container');
+            const searchBtn = document.getElementById('search-btn');
+
+            container.innerHTML = `
+                <div class="loading">
+                    <div class="spinner"></div>
+                    <span>Encoding sequence and searching...</span>
+                </div>
+            `;
+            searchBtn.disabled = true;
+
+            try {
+                const res = await fetch(`${API_BASE}/api/search`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ query, top_k: topK })
+                });
+
+                const data = await res.json();
+
+                if (!res.ok) {
+                    container.innerHTML = `<div class="message error">${data.detail}</div>`;
+                    return;
+                }
+
+                if (data.results.length === 0) {
+                    container.innerHTML = `
+                        <div class="empty-state">
+                            <div class="empty-state-icon">🤷</div>
+                            <p>No similar sequences found</p>
+                        </div>
+                    `;
+                    return;
+                }
+
+                container.innerHTML = `
+                    <div class="results-header">
+                        <span class="results-count">Found <strong>${data.results.length}</strong> similar sequences</span>
+                        <span class="results-count">from ${data.total_indexed.toLocaleString()} indexed</span>
+                    </div>
+                    ${data.results.map((r, i) => `
+                        <div class="result-card" style="animation-delay: ${i * 0.04}s">
+                            <div class="result-header">
+                                <span class="result-rank ${r.rank <= 3 ? 'top-3' : ''}">${r.rank}</span>
+                                <span class="result-score">${(r.score * 100).toFixed(2)}%</span>
+                            </div>
+                            <div class="result-sequence">${escapeHtml(r.sequence)}</div>
+                            <div class="result-metadata">
+                                ${Object.entries(r.metadata)
+                                    .filter(([k]) => !k.startsWith('__'))
+                                    .slice(0, 8)
+                                    .map(([k, v]) => `
+                                        <span class="metadata-tag">
+                                            <span class="metadata-key">${escapeHtml(k)}:</span>
+                                            <span class="metadata-value" title="${escapeHtml(String(v))}">${escapeHtml(String(v).slice(0, 50))}</span>
+                                        </span>
+                                    `).join('')}
+                            </div>
+                        </div>
+                    `).join('')}
+                `;
+            } catch (e) {
+                container.innerHTML = `<div class="message error">Search failed: ${e.message}</div>`;
+            } finally {
+                searchBtn.disabled = false;
+            }
+        }
+
+        function showMessage(text, type = 'info') {
+            const container = document.getElementById('message-container');
+            container.innerHTML = `<div class="message ${type}">${text}</div>`;
+            setTimeout(() => container.innerHTML = '', 4000);
+        }
+
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+    </script>
+</body>
+</html>

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from index-search!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "index-search"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+c
+]

requirements.txt

@@ -0,0 +1,7 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pandas>=2.0.0
+numpy>=1.24.0
+sentence-transformers>=2.2.0
+faiss-cpu>=1.7.4
+python-multipart>=0.0.6