LLM Tornado

FSKB is a semantic search engine and indexing tool for code repositories that uses dense embeddings to provide contextual search.

Key Capabilities:

• Semantic Search: Uses embeddings to understand code context.
• Indexing Engine: Recursively ingests files while honoring .gitignore and skipping heavy directories like node_modules or bin.
• Embedding Providers: Supports Local models (via sentence-transformers or transformers, including GPU/CUDA support and code-specialized models like jinaai/jina-code-embeddings-0.5b) and API-based models (OpenAI, Anthropic, Google Generative AI, VoyageAI via Litellm).
• Vector Storage: Uses ChromaDB for managing dense vector storage.
• MCP Support: Can run as a standard stdio Model Context Protocol (MCP) server.
• UIs: Offers a Graphical Interface (PyQt6) or a headless mode.
• File Watching: Integrates with watchdog to keep the index synchronized with your code changes.

LLM Tornado is a provider-agnostic .NET SDK designed for building, orchestrating, and deploying AI agents and workflows.

Key capabilities include:

• Multi-Provider Support: Built-in connectors for 30+ providers (e.g., OpenAI, Anthropic, Azure, Google, Mistral, DeepSeek) without requiring first-party SDKs.
• Local Deployment: Support for vLLM, Ollama, and LocalAI with request transformation capabilities.
• Agent Orchestration: A framework for coordinating specialist agents using Orchestrator (graphs), Runner (nodes), and Advancer (edges).
• Multimodal Support: Handles text, images, videos, documents, URLs, and audio.
• Vector Database Connectors: Built-in support for Chroma, PgVector, Pinecone, Faiss, and QDrant.
• Advanced Protocols: Integration with Model Context Protocol (LlmTornado.Mcp) and Agent2Agent (LlmTornado.A2A).
• Enterprise Features: Guardrails framework, OpenTelemetry support, and request/response transformation.

For high-performance RAG (Retrieval-Augmented Generation) systems, use a two-stage approach:

1. Initial Retrieval: Use fast methods like vector search (embeddings) to retrieve a larger pool of candidate documents (e.g., top 50).
2. Reranking: Use a sophisticated reranking model to re-score those candidates and select the most relevant ones (e.g., top 5).

This approach balances speed and accuracy while managing costs.

async Task<List<string>> SearchWithRerank(string query, int finalCount = 5)
{
    // Stage 1: Vector search to get candidates
    EmbeddingResult? queryEmbedding = await api.Embeddings.CreateEmbedding(
        EmbeddingModel.OpenAi.Gen2.Ada,
        query);
    
    // Get top 50 candidates from vector database
    List<string> candidates = await VectorSearch(queryEmbedding, topK: 50);
    
    // Stage 2: Rerank candidates
    RerankResult? reranked = await api.Rerank.CreateRerank(
        RerankModel.Cohere.Gen3.Multilingual,
        query,
        candidates,
        topN: finalCount);
    
    // Return reranked results
    return reranked.Results
        .Select(entry => candidates[entry.Index])
        .ToList();
}

Use the Deep Researcher skill when you need depth and validation rather than speed.

Ideal Scenarios

• Strategic Decision-Making: Informing important business or organizational decisions.
• Market Intelligence: Analyzing industries, competitors, trends, or customer segments.
• Technical Investigation: Deep dives into technologies, systems, or tools.
• Academic Research: Literature reviews and topic exploration.
• Due Diligence: Investigating before partnerships or investments.
• Problem Analysis: Understanding complex problems before designing solutions.
• Trend Analysis: Identifying emerging patterns.
• Comparative Studies: Evaluating multiple options or alternatives.

Not Recommended For

• Quick fact-checking: Use simple search instead.
• Real-time information needs: This skill prioritizes depth over speed.
• Highly specialized technical topics: May require human domain experts.
• Proprietary/Paywalled content: Limited to publicly accessible information.

The skill operates through a systematic, iterative process to ensure comprehensive coverage and reliable findings:

1. Define Research Scope and Objectives: Establish research questions, boundaries, and expected deliverables.
2. Conduct Initial Exploratory Research: Perform broad reconnaissance to map the information landscape and identify gaps.
3. Deep Dive into Key Areas: Conduct targeted investigations of subtopics to gather technical details and multiple perspectives.
4. Cross-Reference and Validate Findings: Verify facts across multiple sources and assess credibility to build a validated knowledge base.
5. Synthesize and Analyze Information: Identify patterns, connections, and original insights to address research questions.
6. Generate Structured Research Report: Produce a comprehensive report with an executive summary, organized by themes, including conclusions and source references.

1. Define Research Scope → 2. Exploratory Research → 3. Deep Dive
                                                         ↓
6. Generate Report ← 5. Synthesize & Analyze ← 4. Validate Findings