Vane

Vane implements a unified provider abstraction layer (src/lib/models/providers) that normalizes API calls across 8+ LLM providers including OpenAI, Anthropic, Google Gemini, Groq, Ollama, LMStudio, and Lemonade. The system uses a provider factory pattern to instantiate the correct client based on configuration, handling provider-specific request/response formatting, streaming protocols, and error handling transparently. This allows swapping providers via environment variables without code changes, enabling cost optimization and fallback strategies.

Vane integrates SearXNG (src/lib/searxng.ts), a privacy-respecting meta-search engine, to perform web queries without sending user data to Google, Bing, or other commercial search engines. The integration abstracts SearXNG's HTTP API, handling query formatting, result parsing, and deduplication of results across multiple search backends that SearXNG aggregates. Results are streamed back to the agent with source attribution, enabling the LLM to synthesize answers from multiple sources without exposing user queries to surveillance-based search providers.

Vane streams research results and answer synthesis in real-time to the client using Server-Sent Events (SSE) rather than waiting for complete answer generation. The backend emits events for each research step (search initiated, results retrieved, synthesis started, answer chunk generated), allowing the client to display progress and partial results immediately. The useChat hook (src/app/c/[chatId]/hooks/useChat.ts) handles SSE event parsing and state updates, enabling smooth real-time UI updates without polling or WebSocket complexity.

Vane maintains multi-turn conversation context by storing previous messages and citations in SQLite, passing conversation history to the LLM for each new query. The research agent uses conversation context to understand follow-up questions (e.g., 'Tell me more about X' refers to previous answer), refine searches based on prior results, and avoid redundant research. The system tracks which sources were already cited to avoid repetition and enables the LLM to make context-aware decisions about which new sources to research.

Vane allows switching between LLM providers via environment variables (e.g., PROVIDER=openai, PROVIDER=ollama) without code changes. The configuration system (src/lib/models/providers) reads provider settings from environment variables, instantiates the appropriate provider client, and passes it to the research agent. This enables different deployment configurations: development with local Ollama, staging with Anthropic, production with OpenAI, all from the same codebase. Provider-specific settings (API keys, model names, temperature) are also environment-configurable.

Vane implements a research agent (src/lib/agents/search/researcher) that decomposes user queries into sub-research tasks, executes parallel searches across multiple source types (web, academic papers, discussions, domain-specific databases), and synthesizes results into a coherent answer with citations. The agent uses chain-of-thought reasoning to determine which sources are relevant, iteratively refines searches based on intermediate results, and tracks source provenance throughout the synthesis process. Results are streamed via Server-Sent Events, allowing real-time progress updates to the client.

Vane provides three search modes (Speed, Balanced, Quality) implemented in src/lib/agents/search/index.ts that adjust the research agent's behavior: Speed mode performs single-pass searches with minimal source diversity, Balanced mode uses 2-3 parallel searches across different source types, and Quality mode executes iterative refinement with 5+ searches and cross-source validation. Each mode configures the number of parallel searches, result filtering thresholds, and LLM reasoning depth, allowing users to trade latency for answer comprehensiveness without code changes.

Vane includes a widget system (src/lib/agents/search/widgets) that detects query intent and generates contextual UI cards for structured data types: weather widgets display current conditions and forecasts, stock widgets show price and trend data, calculator widgets handle mathematical expressions, and domain-specific widgets (sports scores, flight info) render relevant data. The system uses LLM-based intent detection to determine widget type, queries specialized APIs or SearXNG for data, and returns structured JSON that the frontend renders as rich UI components rather than plain text.

Vane maintains persistent conversation history using SQLite (src/lib/db) with a schema supporting multi-turn chat sessions, message storage with metadata (timestamps, sources, citations), and user preferences. The session management system (src/app/c/[chatId]) generates unique chat IDs, stores conversation state server-side, and enables resuming conversations across browser sessions. The useChat hook (src/app/c/[chatId]/hooks/useChat.ts) manages client-side state synchronization with the backend, handling optimistic updates and conflict resolution.

Vane supports uploading documents (PDFs, text files) and performing semantic search over them (src/lib/uploads). The system extracts text from uploaded files, chunks documents into semantic units, generates embeddings using the configured LLM provider, stores embeddings in a vector store, and retrieves relevant chunks via similarity search. Uploaded documents are indexed per-session, enabling users to ask questions about their own documents without exposing them to external services. The search integrates with the research agent, allowing hybrid queries that combine web search with document search.

Vane provides image and video search capabilities (src/app/api/images, src/app/api/videos) that query SearXNG for media results and integrate them into the research pipeline. The system returns structured media metadata (URL, title, source, thumbnail) that the frontend renders as image galleries or video embeds. Media search is available as a research action, allowing the research agent to include images and videos in answer synthesis when relevant to the query.

Vane generates contextual query suggestions (src/app/api/suggestions) by analyzing the current conversation context and user query with an LLM, predicting likely follow-up questions or related searches. The system uses the conversation history to understand context, generates 3-5 suggestions that expand or refine the current research direction, and returns them as clickable suggestions in the UI. Suggestions are generated asynchronously and streamed to the client, enabling real-time suggestion updates as the user types.

Vane allows users to restrict searches to specific domains or website lists (src/lib/agents/search/researcher) by passing domain filters to SearXNG queries. The system supports include-list filtering (search only these domains) and exclude-list filtering (search everywhere except these domains), enabling users to focus on authoritative sources (e.g., .edu for academic research, .gov for official information) or avoid low-quality sources. Domain filters are applied at the SearXNG query level, reducing irrelevant results before the LLM synthesis stage.