SEAR: Semantic Enhanced Augmented Retrieval

When to Use This Skill

Invoke SEAR when the user wants to:

• Search documents semantically (not just keyword matching)
• Build a RAG (Retrieval-Augmented Generation) application
• Convert PDF or DOCX files to searchable markdown
• Index code repositories, documentation, or knowledge bases
• Extract relevant content without LLM generation (pure retrieval)
• Search across multiple document collections (multi-corpus)
• Get line-level citations with exact source tracking

Core Capabilities

1. Document Conversion

Convert PDF and DOCX files to LLM-optimized markdown:

# Basic conversion
sear convert document.pdf

# Custom output directory
sear convert report.docx --output-dir docs/

# OCR for scanned documents with language hints
sear convert scanned.pdf --force-ocr --lang heb+eng

# Keep original formatting (niqqud, etc.)
sear convert hebrew.pdf --no-normalize

Features:

• Smart OCR: Auto-detects text layer, falls back to OCR if needed
• Language support: Hebrew, English, mixed content (auto-detected)
• Token optimization: Removes niqqud, styling, formatting
• RAG-ready output: Metadata headers + page separators for citations

2. Indexing Documents

Create searchable FAISS indices from text files:

# Basic indexing
sear index document.txt my_corpus

# With GPU acceleration (5-10x faster on large datasets)
sear index large_doc.txt production_corpus --gpu

# Check GPU availability
sear gpu-info

Index locations:

faiss_indices/<corpus_name>/

Project Structure: SEAR uses a standard Python src-layout:

• src/sear/

  - Main package directory

  • cli.py

    - CLI interface

  • core.py

    - Core library functions

  • __init__.py

    - Public API exports

• src/doc_converter/

  - Document conversion module

• tests/

  - Test suite

• examples/

  - Example code

3. Semantic Search with LLM

Search and get LLM-synthesized answers with citations:

# Basic search (uses local Ollama by default)
sear search "how does authentication work?" --corpus my_corpus

# With Anthropic Claude (higher quality)
export ANTHROPIC_API_KEY=sk-ant-xxx
sear search "explain the security model" --corpus my_corpus --provider anthropic

# Multi-corpus search
sear search "query" --corpus docs --corpus code --corpus wiki

Output: Synthesized answer with line-level citations:

[corpus_name] file.txt:42-45

4. Content Extraction (No LLM)

Retrieve relevant chunks without generation (pure retrieval):

# Extract matching chunks
sear extract "security vulnerabilities" --corpus codebase

# Adjust similarity threshold (default: 0.30)
sear extract "query" --corpus docs --min-score 0.40

# Limit results
sear extract "query" --corpus docs --top-k 5

Use case: When you need raw content for further processing, not LLM answers.

Typical Workflows

Workflow 1: Process and Search PDFs

# Step 1: Convert PDF to markdown
sear convert research_paper.pdf

# Step 2: Index the converted markdown
sear index converted_md/research_paper.md research_corpus

# Step 3: Search with questions
sear search "what were the main findings?" --corpus research_corpus

Workflow 2: Multi-Corpus Knowledge Base

# Index different sources
sear index documentation.txt docs_corpus
sear index codebase.txt code_corpus
sear index articles.txt articles_corpus

# Search across all corpuses
sear search "how to implement feature X?" \
  --corpus docs_corpus \
  --corpus code_corpus \
  --corpus articles_corpus

Workflow 3: Extract Content for Analysis

# Extract relevant chunks for manual review
sear extract "security concerns" --corpus audit_corpus > security_findings.txt

# Use extracted content in further analysis
# (No LLM generation, just pure retrieval)

Performance Optimization

GPU Acceleration

• Small corpuses (<500 chunks): Use

  --no-gpu

  (CPU is faster)
• Medium corpuses (500-10k chunks): GPU provides 2-3x speedup
• Large corpuses (>10k chunks): GPU provides 5-10x speedup

# Let SEAR decide automatically (recommended)
sear index large.txt corpus

# Force GPU
sear index large.txt corpus --gpu

# Force CPU
sear index large.txt corpus --no-gpu

Quality Filtering

SEAR uses empirical similarity thresholds (default: 0.30) to filter low-quality matches:

# Adjust threshold for stricter matching
sear search "query" --corpus docs --min-score 0.40

# Lower threshold for broader matching
sear search "query" --corpus docs --min-score 0.20

When results are insufficient (<2 matches), SEAR prompts for query refinement instead of generating answers from noise.

LLM Provider Selection

Local Ollama (Default - Zero Cost)

# Uses qwen2.5:0.5b by default
sear search "query" --corpus docs

# Fast (~5s), adequate quality, $0 cost

Anthropic Claude (Higher Quality)

# Set API key
export ANTHROPIC_API_KEY=sk-ant-xxx

# Use Claude 3.5 Sonnet
sear search "query" --corpus docs --provider anthropic

# Better reasoning, structured output, ~10s, ~$0.01/query

Corpus Management

# List all available corpuses
sear list

# Delete a corpus
sear delete corpus_name

Best Practices

1. Document Preparation:

   • Convert PDFs/DOCX first:

     sear convert

     before indexing
   • For code repos: Use

     gitingest

     or concatenate files
   • Keep documents focused (better retrieval quality)

2. Indexing Strategy:

   • Use meaningful corpus names (e.g.,

     project_docs

     ,

     codebase_v2

     )
   • Separate different domains into different corpuses
   • Re-index when documents are updated

3. Search Quality:

   • Start with default threshold (0.30)
   • Use multi-corpus search for comprehensive coverage
   • Refine queries if results are insufficient

4. GPU Usage:

   • Don't force

     --gpu

     on small datasets
   • Let SEAR decide automatically
   • Monitor with

     sear gpu-info

5. Cost Optimization:

   • Use local Ollama for development/iteration
   • Use Anthropic Claude for production/critical analysis
   • Use

     extract

     command when you don't need LLM synthesis

Architecture

Documents (PDF/DOCX/TXT)
    ↓
[src/doc_converter] ← PDF/DOCX → Markdown (with OCR)
    ↓
Text Files
    ↓
[Embedding: all-minilm via Ollama] ← 384-dimensional vectors
    ↓
[FAISS Index] ← CPU or GPU acceleration
    ↓
[Query Embedding]
    ↓
[Similarity Search] ← Quality filtering (threshold: 0.30)
    ↓
Top-k Relevant Chunks
    ↓
[LLM Synthesis: Ollama/Anthropic] ← Optional (skip for extract)
    ↓
Answer + Line-Level Citations

Key Differentiators

vs AWS NOVA/Titan Embeddings:

• ✅ Zero cost (100% local)
• ✅ Complete document pipeline (convert → index → search)
• ✅ GPU acceleration (5-10x on large datasets)
• ✅ Line-level citations
• ✅ 100% offline/private
• ❌ Text-only (no multimodal)

vs Traditional RAG:

• ✅ Quality-aware filtering (empirical thresholds)
• ✅ Multi-corpus parallel search
• ✅ Content extraction without LLM
• ✅ 99% token reduction (retrieval-first)
• ✅ Deterministic retrieval (100%)

Installation Requirements

SEAR must be installed in the user's environment:

# Basic installation
pip install -e .

# With document conversion (PDF/DOCX)
pip install -e ".[converter]"

# With GPU support
pip install -e ".[gpu]"

# With Anthropic Claude
pip install -e ".[anthropic]"

# Install everything
pip install -e ".[all]"

# Install Ollama models
ollama pull all-minilm
ollama pull qwen2.5:0.5b

Common Issues

Issue: "ModuleNotFoundError: No module named 'doc_converter'" Solution: Install converter dependencies:

pip install -e ".[converter]"

Issue: GPU not detected Solution: Check CUDA toolkit:

sear gpu-info

, install

faiss-gpu

if needed

Issue: Low-quality results Solution: Adjust threshold:

--min-score 0.40

or refine query

Issue: Slow search on small corpus Solution: Use CPU mode:

--no-gpu

Example Use Cases

1. Legal Document Review: Convert contracts to markdown, index, extract clauses
2. Code Documentation: Index codebase + docs, semantic search for implementations
3. Research Analysis: Convert papers to markdown, multi-paper semantic search
4. Knowledge Management: Index company docs, wiki, policies - searchable knowledge base
5. Compliance Auditing: Extract policy-relevant sections without reading everything

Additional Resources

• Repository: https://github.com/Guard8-ai/SEAR
• Documentation: See README.md, INSTALL.md, GPU_SUPPORT.md
• Benchmarks: See BENCHMARK_RESULTS.md
• Examples: See examples/ directory