probe

probe

Probe is an AI-friendly, fully local, semantic code search engine which which works with for large codebases. The final missing building block for next generation of AI coding tools.

Stars: 54

Visit
screenshot

Probe is an AI-friendly, fully local, semantic code search tool designed to power the next generation of AI coding assistants. It combines the speed of ripgrep with the code-aware parsing of tree-sitter to deliver precise results with complete code blocks, making it perfect for large codebases and AI-driven development workflows. Probe is fully local, keeping code on the user's machine without relying on external APIs. It supports multiple languages, offers various search options, and can be used in CLI mode, MCP server mode, AI chat mode, and web interface. The tool is designed to be flexible, fast, and accurate, providing developers and AI models with full context and relevant code blocks for efficient code exploration and understanding.

README:

Probe Logo

Probe

Probe is an AI-friendly, fully local, semantic code search tool designed to power the next generation of AI coding assistants. By combining the speed of ripgrep with the code-aware parsing of tree-sitter, Probe delivers precise results with complete code blocks—perfect for large codebases and AI-driven development workflows.

Table of Contents

Quick Start

NPM Installation The easiest way to install Probe is via npm, which also installs the binary:

npm install -g @buger/probe

Basic Search Example Search for code containing the phrase "llm pricing" in the current directory:

probe search "llm pricing" ./

Advanced Search (with Token Limiting) Search for "partial prompt injection" in the current directory but limit the total tokens to 10000 (useful for AI tools with context window constraints):

probe search "prompt injection" ./ --max-tokens 10000

Elastic Search Queries Use advanced query syntax for more powerful searches:

# Use AND operator for terms that must appear together
probe search "error AND handling" ./

# Use OR operator for alternative terms
probe search "login OR authentication OR auth" ./src

# Group terms with parentheses for complex queries
probe search "(error OR exception) AND (handle OR process)" ./

# Use wildcards for partial matching
probe search "auth* connect*" ./

# Exclude terms with NOT operator
probe search "database NOT sqlite" ./

Extract Code Blocks Extract a specific function or code block containing line 42 in main.rs:

probe extract src/main.rs:42

You can even paste failing test output and it will extract needed files and AST out of it, like:

go test | probe extract

Interactive AI Chat Use the AI assistant to ask questions about your codebase:

# Run directly with npx (no installation needed)
npx -y @buger/probe-chat

# Set your API key first
export ANTHROPIC_API_KEY=your_api_key
# Or for OpenAI
# export OPENAI_API_KEY=your_api_key

# Specify a directory to search (optional)
npx -y @buger/probe-chat /path/to/your/project

Node.js SDK Usage Use Probe programmatically in your Node.js applications with the Vercel AI SDK:

import { ProbeChat } from '@buger/probe-chat';
import { StreamingTextResponse } from 'ai';

// Create a chat instance
const chat = new ProbeChat({
  model: 'claude-3-sonnet-20240229',
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  allowedFolders: ['/path/to/your/project']
});

// In an API route or Express handler
export async function POST(req) {
  const { messages } = await req.json();
  const userMessage = messages[messages.length - 1].content;
  
  // Get a streaming response from the AI
  const stream = await chat.chat(userMessage, { stream: true });
  
  // Return a streaming response
  return new StreamingTextResponse(stream);
}

// Or use it in a non-streaming way
const response = await chat.chat('How is authentication implemented?');
console.log(response);

MCP server

Integrate with any AI editor:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@buger/probe-mcp"
      ]
    }
  }
}

Example queries:

"Do the probe and search my codebase for implementations of the ranking algorithm"

"Using probe find all functions related to error handling in the src directory"

Features

  • AI-Friendly: Extracts entire functions, classes, or structs so AI models get full context.
  • Fully Local: Keeps your code on your machine—no external APIs.
  • Powered by ripgrep: Extremely fast scanning of large codebases.
  • Tree-sitter Integration: Parses and understands code structure accurately.
  • Re-Rankers & NLP: Uses tokenization, stemming, BM25, TF-IDF, or hybrid ranking methods for better search results.
  • Code Extraction: Extract specific code blocks or entire files with the extract command.
  • Multi-Language: Works with popular languages like Rust, Python, JavaScript, TypeScript, Java, Go, C/C++, Swift, C#, and more.
  • Interactive AI Chat: AI assistant example in the examples directory that can answer questions about your codebase using Claude or GPT models.
  • Flexible: Run as a CLI tool, an MCP server, or an interactive AI chat.

Installation

Quick Installation

You can install Probe with a single command using either npm or curl:

Using npm (Recommended for Node.js users)

npm install -g @buger/probe

Using curl (For any platform)

curl -fsSL https://raw.githubusercontent.com/buger/probe/main/install.sh | bash

What the curl script does:

  1. Detects your operating system and architecture
  2. Fetches the latest release from GitHub
  3. Downloads the appropriate binary for your system
  4. Verifies the checksum for security
  5. Installs the binary to /usr/local/bin

Requirements

  • Operating Systems: macOS, Linux, or Windows (with MSYS/Git Bash/WSL)
  • Architectures: x86_64 (all platforms) or ARM64 (macOS only)
  • Tools: curl, bash, and sudo/root privileges

Manual Installation

  1. Download the appropriate binary for your platform from the GitHub Releases page:
    • probe-x86_64-linux.tar.gz for Linux (x86_64)
    • probe-x86_64-darwin.tar.gz for macOS (Intel)
    • probe-aarch64-darwin.tar.gz for macOS (Apple Silicon)
    • probe-x86_64-windows.zip for Windows
  2. Extract the archive: 
    # For Linux/macOS
tar -xzf probe-*-*.tar.gz

# For Windows
unzip probe-x86_64-windows.zip
  3. Move the binary to a location in your PATH: 
    # For Linux/macOS
sudo mv probe /usr/local/bin/

# For Windows
# Move probe.exe to a directory in your PATH

Building from Source

  1. Install Rust and Cargo (if not already installed): 
    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  2. Clone this repository: 
    git clone https://github.com/buger/probe.git
cd code-search
  3. Build the project: 
    cargo build --release
  4. (Optional) Install globally: 
    cargo install --path .

Verifying the Installation

probe --version

Troubleshooting

  • Permissions: Ensure you can write to /usr/local/bin.
  • System Requirements: Double-check your OS/architecture.
  • Manual Install: If the quick install script fails, try Manual Installation.
  • GitHub Issues: Report issues on the GitHub repository.

Uninstalling

sudo rm /usr/local/bin/probe

Usage

Probe can be used in three main modes:

  1. CLI Mode: Direct code search and extraction from the command line
  2. MCP Server Mode: Run as a server exposing search functionality via MCP
  3. Web Interface: Browser-based UI for code exploration

Additionally, there are example implementations in the examples directory:

  • AI Chat Example: Interactive AI assistant for code exploration (in examples/chat)
  • Web Interface Example: Browser-based UI for code exploration (in examples/web)

CLI Mode

Search Command

probe search <SEARCH_PATTERN> [OPTIONS]
Key Options
  • <SEARCH_PATTERN>: Pattern to search for (required)
  • --files-only: Skip AST parsing; only list files with matches
  • --ignore: Custom ignore patterns (in addition to .gitignore)
  • --exclude-filenames, -n: Exclude files whose names match query words (filename matching is enabled by default)
  • --reranker, -r: Choose a re-ranking algorithm (hybrid, hybrid2, bm25, tfidf)
  • --frequency, -s: Frequency-based search (tokenization, stemming, stopword removal)
  • --exact: Exact matching (overrides frequency search)
  • --max-results: Maximum number of results to return
  • --max-bytes: Maximum total bytes of code to return
  • --max-tokens: Maximum total tokens of code to return (useful for AI)
  • --allow-tests: Include test files and test code blocks
  • --any-term: Match files containing any query terms (default behavior)
  • --no-merge: Disable merging of adjacent code blocks after ranking (merging enabled by default)
  • --merge-threshold: Max lines between code blocks to consider them adjacent for merging (default: 5)
Examples
# 1) Search for "setTools" in the current directory with frequency-based search
probe search "setTools"

# 2) Search for "impl" in ./src with exact matching
probe search "impl"  ./src --exact

# 3) Search for "keyword" returning only the top 5 results
probe search "keyword" --max-tokens 10000

# 4) Search for "function" and disable merging of adjacent code blocks
probe search "function" --no-merge

Extract Command

The extract command allows you to extract code blocks from files. When a line number is specified, it uses tree-sitter to find the closest suitable parent node (function, struct, class, etc.) for that line. You can also specify a symbol name to extract the code block for that specific symbol.

probe extract <FILES> [OPTIONS]
Key Options
  • <FILES>: Files to extract from (can include line numbers with colon, e.g., file.rs:10, or symbol names with hash, e.g., file.rs#function_name)
  • --allow-tests: Include test files and test code blocks in results
  • -c, --context <LINES>: Number of context lines to include before and after the extracted block (default: 0)
  • -f, --format <FORMAT>: Output format (markdown, plain, json) (default: markdown)
Examples
# 1) Extract a function containing line 42 from main.rs
probe extract src/main.rs:42

# 2) Extract multiple files or blocks
probe extract src/main.rs:42 src/lib.rs:15 src/cli.rs

# 3) Extract with JSON output format
probe extract src/main.rs:42 --format json

# 4) Extract with 5 lines of context around the specified line
probe extract src/main.rs:42 --context 5

# 5) Extract a specific function by name (using # symbol syntax)
probe extract src/main.rs#handle_extract

# 6) Extract a specific line range (using : syntax)
probe extract src/main.rs:10-20

# 7) Extract from stdin (useful with error messages or compiler output)
cat error_log.txt | probe extract

The extract command can also read file paths from stdin, making it useful for processing compiler errors or log files:

# Extract code blocks from files mentioned in error logs
grep -r "error" ./logs/ | probe extract

MCP Server

Add the following to your AI editor's MCP configuration file:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@buger/probe-mcp"
      ]
    }
  }
}

  • Example Usage in AI Editors:

    Once configured, you can ask your AI assistant to search your codebase with natural language queries like:

    "Do the probe and search my codebase for implementations of the ranking algorithm"

    "Using probe find all functions related to error handling in the src directory"

AI Chat Mode

The AI chat functionality is available as a standalone npm package that can be run directly with npx.

Using npx (Recommended)

# Run directly with npx (no installation needed)
npx -y @buger/probe-chat

# Set your API key
export ANTHROPIC_API_KEY=your_api_key
# Or for OpenAI
# export OPENAI_API_KEY=your_api_key

# Or specify a directory to search
npx -y @buger/probe-chat /path/to/your/project

Using the npm package

# Install globally
npm install -g @buger/probe-chat

# Start the chat interface
probe-chat

Using the example code

# Navigate to the examples directory
cd examples/chat

# Install dependencies
npm install

# Set your API key
export ANTHROPIC_API_KEY=your_api_key
# Or for OpenAI
# export OPENAI_API_KEY=your_api_key

# Start the chat interface
node index.js

This starts an interactive CLI interface where you can ask questions about your codebase and get AI-powered responses.

Features

  • AI-Powered Search: Uses LLMs to understand your questions and search the codebase intelligently
  • Multi-Model Support: Works with both Anthropic's Claude and OpenAI's GPT models
  • Token Tracking: Monitors token usage for both requests and responses
  • Conversation History: Maintains context across multiple interactions
  • Colored Output: Provides a user-friendly terminal interface with syntax highlighting

Configuration

Configure the chat using environment variables:

# Use Claude models (recommended)
export ANTHROPIC_API_KEY=your_api_key

# Or use OpenAI models
export OPENAI_API_KEY=your_api_key

# Override the default model
export MODEL_NAME=claude-3-opus-20240229

# Override API URLs (useful for proxies or enterprise deployments)
export ANTHROPIC_API_URL=https://your-anthropic-proxy.com
export OPENAI_API_URL=https://your-openai-proxy.com/v1

# Enable debug mode for detailed logging
export DEBUG=1

Example Usage

❯ How does the ranking algorithm work?

─ Response ─────────────────────────────────────────────────────────
I'll explain how the ranking algorithm works in the codebase.

The ranking system in Probe uses multiple algorithms to sort search results by relevance. The main ranking algorithms are:

1. TF-IDF (Term Frequency-Inverse Document Frequency)
2. BM25 (Best Matching 25)
3. Hybrid (a combination approach)

Let me break down each approach:

## TF-IDF Ranking

TF-IDF weighs terms based on how frequently they appear in a document versus how common they are across all documents.

Key implementation details:
- Term frequency (TF) measures how often a term appears in a document
- Inverse document frequency (IDF) measures how rare a term is across all documents
- Final score is calculated as TF × IDF

## BM25 Ranking

BM25 is an advanced ranking function that improves upon TF-IDF by adding document length normalization.

Key implementation details:
- Uses parameters k1 (term frequency saturation) and b (document length normalization)
- Handles edge cases like empty documents and rare terms
- Provides better results for longer documents

## Hybrid Ranking

The hybrid approach combines multiple ranking signals for better results:

1. Combines scores from both TF-IDF and BM25
2. Considers document length and term positions
3. Applies normalization to ensure fair comparison

The default reranker is "hybrid" which provides the best overall results for code search.

The ranking implementation can be found in `src/search/result_ranking.rs`.
─────────────────────────────────────────────────────────────────────
Token Usage: Request: 1245 Response: 1532 (Current message only: ~1532)
Total: 2777 tokens (Cumulative for entire session)
─────────────────────────────────────────────────────────────────────

Web Interface

Probe includes a web-based chat interface that provides a user-friendly way to interact with your codebase using AI. You can run it directly with npx or set it up manually.

Quick Start with npx

# Run directly with npx (no installation needed)
npx -y @buger/probe-web

# Set your API key first
export ANTHROPIC_API_KEY=your_api_key

# Configure allowed folders (optional)
export ALLOWED_FOLDERS=/path/to/folder1,/path/to/folder2

Manual Setup and Configuration

  1. Navigate to the web directory:

    cd web

  2. Install dependencies:

    npm install

  3. Configure environment variables: Create or edit the .env file in the web directory:

    ANTHROPIC_API_KEY=your_anthropic_api_key
PORT=8080
ALLOWED_FOLDERS=/path/to/folder1,/path/to/folder2

  4. Start the server:

    npm start

  5. Access the web interface: Open your browser and navigate to http://localhost:8080

Technical Details

  • Built with vanilla JavaScript and Node.js
  • Uses the Vercel AI SDK for Claude integration
  • Executes Probe commands via the probeTool.js module
  • Renders markdown with Marked.js and syntax highlighting with Highlight.js
  • Supports Mermaid.js for diagram generation and visualization

Supported Languages

Probe currently supports:

  • Rust (.rs)
  • JavaScript / JSX (.js, .jsx)
  • TypeScript / TSX (.ts, .tsx)
  • Python (.py)
  • Go (.go)
  • C / C++ (.c, .h, .cpp, .cc, .cxx, .hpp, .hxx)
  • Java (.java)
  • Ruby (.rb)
  • PHP (.php)
  • Swift (.swift)
  • C# (.cs)
  • Markdown (.md, .markdown)

How It Works

Probe combines fast file scanning with deep code parsing to provide highly relevant, context-aware results:

  1. Ripgrep Scanning
    Probe uses ripgrep to quickly search across your files, identifying lines that match your query. Ripgrep's efficiency allows it to handle massive codebases at lightning speed.

  2. AST Parsing with Tree-sitter
    For each file containing matches, Probe uses tree-sitter to parse the file into an Abstract Syntax Tree (AST). This process ensures that code blocks (functions, classes, structs) can be identified precisely.

  3. NLP & Re-Rankers
    Next, Probe applies classical NLP methods—tokenization, stemming, and stopword removal—alongside re-rankers such as BM25, TF-IDF, or the hybrid approach (combining multiple ranking signals). This step elevates the most relevant code blocks to the top, especially helpful for AI-driven searches.

  4. Block Extraction
    Probe identifies the smallest complete AST node containing each match (e.g., a full function or class). It extracts these code blocks and aggregates them into search results.

  5. Context for AI
    Finally, these structured blocks can be returned directly or fed into an AI system. By providing the full context of each code segment, Probe helps AI models navigate large codebases and produce more accurate insights.

Adding Support for New Languages

  1. Tree-sitter Grammar: In Cargo.toml, add the tree-sitter parser for the new language.
  2. Language Module: Create a new file in src/language/ for parsing logic.
  3. Implement Language Trait: Adapt the parse method for the new language constructs.
  4. Factory Update: Register your new language in Probe's detection mechanism.

Releasing New Versions

Probe uses GitHub Actions for multi-platform builds and releases.

  1. Update Cargo.toml with the new version.
  2. Create a new Git tag: 
    git tag -a vX.Y.Z -m "Release vX.Y.Z"
git push origin vX.Y.Z
  3. GitHub Actions will build, package, and draft a new release with checksums.

Each release includes:

  • Linux binary (x86_64)
  • macOS binaries (x86_64 and aarch64)
  • Windows binary (x86_64)
  • SHA256 checksums

We believe that local, privacy-focused, semantic code search is essential for the future of AI-assisted development. Probe is built to empower developers and AI alike to navigate and comprehend large codebases more effectively.

For questions or contributions, please open an issue on GitHub. Happy coding—and searching!

For Tasks:

Click tags to check more tools for each tasks
search code blocks extract functions ask code-related questions integrate with ai editor explore codebase interactively

For Jobs:

software developer ai engineer code analyst technical lead data scientist

Alternative AI tools for probe

Similar Open Source Tools

probe Screenshot
probe

Probe is an AI-friendly, fully local, semantic code search tool designed to power the next generation of AI coding assistants. It combines the speed of ripgrep with the code-aware parsing of tree-sitter to deliver precise results with complete code blocks, making it perfect for large codebases and AI-driven development workflows. Probe is fully local, keeping code on the user's machine without relying on external APIs. It supports multiple languages, offers various search options, and can be used in CLI mode, MCP server mode, AI chat mode, and web interface. The tool is designed to be flexible, fast, and accurate, providing developers and AI models with full context and relevant code blocks for efficient code exploration and understanding.

github
: 54
WatermarkRemover-AI Screenshot
WatermarkRemover-AI

WatermarkRemover-AI is an advanced application that utilizes AI models for precise watermark detection and seamless removal. It leverages Florence-2 for watermark identification and LaMA for inpainting. The tool offers both a command-line interface (CLI) and a PyQt6-based graphical user interface (GUI), making it accessible to users of all levels. It supports dual modes for processing images, advanced watermark detection, seamless inpainting, customizable output settings, real-time progress tracking, dark mode support, and efficient GPU acceleration using CUDA.

github
: 78
ebook2audiobook Screenshot
ebook2audiobook

ebook2audiobook is a CPU/GPU converter tool that converts eBooks to audiobooks with chapters and metadata using tools like Calibre, ffmpeg, XTTSv2, and Fairseq. It supports voice cloning and a wide range of languages. The tool is designed to run on 4GB RAM and provides a new v2.0 Web GUI interface for user-friendly interaction. Users can convert eBooks to text format, split eBooks into chapters, and utilize high-quality text-to-speech functionalities. Supported languages include Arabic, Chinese, English, French, German, Hindi, and many more. The tool can be used for legal, non-DRM eBooks only and should be used responsibly in compliance with applicable laws.

github
: 9.0k
swift-ocr-llm-powered-pdf-to-markdown Screenshot
swift-ocr-llm-powered-pdf-to-markdown

Swift OCR is a powerful tool for extracting text from PDF files using OpenAI's GPT-4 Turbo with Vision model. It offers flexible input options, advanced OCR processing, performance optimizations, structured output, robust error handling, and scalable architecture. The tool ensures accurate text extraction, resilience against failures, and efficient handling of multiple requests.

github
: 219
CrewAI-Studio Screenshot
CrewAI-Studio

CrewAI Studio is an application with a user-friendly interface for interacting with CrewAI, offering support for multiple platforms and various backend providers. It allows users to run crews in the background, export single-page apps, and use custom tools for APIs and file writing. The roadmap includes features like better import/export, human input, chat functionality, automatic crew creation, and multiuser environment support.

github
: 682
polyfire-js Screenshot
polyfire-js

Polyfire is an all-in-one managed backend for AI apps that allows users to build AI apps directly from the frontend, eliminating the need for a separate backend. It simplifies the process by providing most backend services in just a few lines of code. With Polyfire, users can easily create chatbots, transcribe audio files to text, generate simple text, create a long-term memory, and generate images with Dall-E. The tool also offers starter guides and tutorials to help users get started quickly and efficiently.

github
: 128
farfalle Screenshot
farfalle

Farfalle is an open-source AI-powered search engine that allows users to run their own local LLM or utilize the cloud. It provides a tech stack including Next.js for frontend, FastAPI for backend, Tavily for search API, Logfire for logging, and Redis for rate limiting. Users can get started by setting up prerequisites like Docker and Ollama, and obtaining API keys for Tavily, OpenAI, and Groq. The tool supports models like llama3, mistral, and gemma. Users can clone the repository, set environment variables, run containers using Docker Compose, and deploy the backend and frontend using services like Render and Vercel.

github
: 2.1k
julep Screenshot
julep

Julep is an advanced platform for creating stateful and functional AI apps powered by large language models. It offers features like statefulness by design, automatic function calling, production-ready deployment, cron-like asynchronous functions, 90+ built-in tools, and the ability to switch between different LLMs easily. Users can build AI applications without the need to write code for embedding, saving, and retrieving conversation history, and can connect to third-party applications using Composio. Julep simplifies the process of getting started with AI apps, whether they are conversational, functional, or agentic.

github
: 4.9k
R2R Screenshot
R2R

R2R (RAG to Riches) is a fast and efficient framework for serving high-quality Retrieval-Augmented Generation (RAG) to end users. The framework is designed with customizable pipelines and a feature-rich FastAPI implementation, enabling developers to quickly deploy and scale RAG-based applications. R2R was conceived to bridge the gap between local LLM experimentation and scalable production solutions. **R2R is to LangChain/LlamaIndex what NextJS is to React**. A JavaScript client for R2R deployments can be found here. ### Key Features * **🚀 Deploy** : Instantly launch production-ready RAG pipelines with streaming capabilities. * **🧩 Customize** : Tailor your pipeline with intuitive configuration files. * **🔌 Extend** : Enhance your pipeline with custom code integrations. * **⚖️ Autoscale** : Scale your pipeline effortlessly in the cloud using SciPhi. * **🤖 OSS** : Benefit from a framework developed by the open-source community, designed to simplify RAG deployment.

github
: 5.1k
Hacx-GPT Screenshot
Hacx-GPT

Hacx GPT is a cutting-edge AI tool developed by BlackTechX, inspired by WormGPT, designed to push the boundaries of natural language processing. It is an advanced broken AI model that facilitates seamless and powerful interactions, allowing users to ask questions and perform various tasks. The tool has been rigorously tested on platforms like Kali Linux, Termux, and Ubuntu, offering powerful AI conversations and the ability to do anything the user wants. Users can easily install and run Hacx GPT on their preferred platform to explore its vast capabilities.

github
: 102
trendFinder Screenshot
trendFinder

Trend Finder is a tool designed to help users stay updated on trending topics on social media by collecting and analyzing posts from key influencers. It sends Slack notifications when new trends or product launches are detected, saving time, keeping users informed, and enabling quick responses to emerging opportunities. The tool features AI-powered trend analysis, social media and website monitoring, instant Slack notifications, and scheduled monitoring using cron jobs. Built with Node.js and Express.js, Trend Finder integrates with Together AI, Twitter/X API, Firecrawl, and Slack Webhooks for notifications.

github
: 2.2k
DevoxxGenieIDEAPlugin Screenshot
DevoxxGenieIDEAPlugin

Devoxx Genie is a Java-based IntelliJ IDEA plugin that integrates with local and cloud-based LLM providers to aid in reviewing, testing, and explaining project code. It supports features like code highlighting, chat conversations, and adding files/code snippets to context. Users can modify REST endpoints and LLM parameters in settings, including support for cloud-based LLMs. The plugin requires IntelliJ version 2023.3.4 and JDK 17. Building and publishing the plugin is done using Gradle tasks. Users can select an LLM provider, choose code, and use commands like review, explain, or generate unit tests for code analysis.

github
: 376
DeepSeekAI Screenshot
DeepSeekAI

DeepSeekAI is a browser extension plugin that allows users to interact with AI by selecting text on web pages and invoking the DeepSeek large model to provide AI responses. The extension enhances browsing experience by enabling users to get summaries or answers for selected text directly on the webpage. It features context text selection, API key integration, draggable and resizable window, AI streaming replies, Markdown rendering, one-click copy, re-answer option, code copy functionality, language switching, and multi-turn dialogue support. Users can install the extension from Chrome Web Store or Edge Add-ons, or manually clone the repository, install dependencies, and build the extension. Configuration involves entering the DeepSeek API key in the extension popup window to start using the AI-driven responses.

github
: 203
recommendarr Screenshot
recommendarr

Recommendarr is a tool that generates personalized TV show and movie recommendations based on your Sonarr, Radarr, Plex, and Jellyfin libraries using AI. It offers AI-powered recommendations, media server integration, flexible AI support, watch history analysis, customization options, and dark/light mode toggle. Users can connect their media libraries and watch history services, configure AI service settings, and get personalized recommendations based on genre, language, and mood/vibe preferences. The tool works with any OpenAI-compatible API and offers various recommended models for different cost options and performance levels. It provides personalized suggestions, detailed information, filter options, watch history analysis, and one-click adding of recommended content to Sonarr/Radarr.

github
: 235
rigging Screenshot
rigging

Rigging is a lightweight LLM framework designed to simplify the usage of language models in production code. It offers structured Pydantic models for text output, supports various models like LiteLLM and transformers, and provides features such as defining prompts as python functions, simple tool use, storing models as connection strings, async batching for large scale generation, and modern Python support with type hints and async capabilities. Rigging is developed by dreadnode and is suitable for tasks like building chat pipelines, running completions, tracking behavior with tracing, playing with generation parameters, and scaling up with iterating and batching.

github
: 246
aiaio Screenshot
aiaio

aiaio (AI-AI-O) is a lightweight, privacy-focused web UI for interacting with AI models. It supports both local and remote LLM deployments through OpenAI-compatible APIs. The tool provides features such as dark/light mode support, local SQLite database for conversation storage, file upload and processing, configurable model parameters through UI, privacy-focused design, responsive design for mobile/desktop, syntax highlighting for code blocks, real-time conversation updates, automatic conversation summarization, customizable system prompts, WebSocket support for real-time updates, Docker support for deployment, multiple API endpoint support, and multiple system prompt support. Users can configure model parameters and API settings through the UI, handle file uploads, manage conversations, and use keyboard shortcuts for efficient interaction. The tool uses SQLite for storage with tables for conversations, messages, attachments, and settings. Contributions to the project are welcome under the Apache License 2.0.

github
: 282

For similar tasks

probe Screenshot
probe

Probe is an AI-friendly, fully local, semantic code search tool designed to power the next generation of AI coding assistants. It combines the speed of ripgrep with the code-aware parsing of tree-sitter to deliver precise results with complete code blocks, making it perfect for large codebases and AI-driven development workflows. Probe is fully local, keeping code on the user's machine without relying on external APIs. It supports multiple languages, offers various search options, and can be used in CLI mode, MCP server mode, AI chat mode, and web interface. The tool is designed to be flexible, fast, and accurate, providing developers and AI models with full context and relevant code blocks for efficient code exploration and understanding.

github
: 54
blockoli Screenshot
blockoli

Blockoli is a high-performance tool for code indexing, embedding generation, and semantic search tool for use with LLMs. It is built in Rust and uses the ASTerisk crate for semantic code parsing. Blockoli allows you to efficiently index, store, and search code blocks and their embeddings using vector similarity. Key features include indexing code blocks from a codebase, generating vector embeddings for code blocks using a pre-trained model, storing code blocks and their embeddings in a SQLite database, performing efficient similarity search on code blocks using vector embeddings, providing a REST API for easy integration with other tools and platforms, and being fast and memory-efficient due to its implementation in Rust.

github
: 53

For similar jobs

sweep Screenshot
sweep

Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.

github
: 7.1k
teams-ai Screenshot
teams-ai

The Teams AI Library is a software development kit (SDK) that helps developers create bots that can interact with Teams and Microsoft 365 applications. It is built on top of the Bot Framework SDK and simplifies the process of developing bots that interact with Teams' artificial intelligence capabilities. The SDK is available for JavaScript/TypeScript, .NET, and Python.

github
: 502
ai-guide Screenshot
ai-guide

This guide is dedicated to Large Language Models (LLMs) that you can run on your home computer. It assumes your PC is a lower-end, non-gaming setup.

github
: 159
classifai Screenshot
classifai

Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence. Tap into leading cloud-based services like OpenAI, Microsoft Azure AI, Google Gemini and IBM Watson to augment your WordPress-powered websites. Publish content faster while improving SEO performance and increasing audience engagement. ClassifAI integrates Artificial Intelligence and Machine Learning technologies to lighten your workload and eliminate tedious tasks, giving you more time to create original content that matters.

github
: 619
chatbot-ui Screenshot
chatbot-ui

Chatbot UI is an open-source AI chat app that allows users to create and deploy their own AI chatbots. It is easy to use and can be customized to fit any need. Chatbot UI is perfect for businesses, developers, and anyone who wants to create a chatbot.

github
: 27.7k
BricksLLM Screenshot
BricksLLM

BricksLLM is a cloud native AI gateway written in Go. Currently, it provides native support for OpenAI, Anthropic, Azure OpenAI and vLLM. BricksLLM aims to provide enterprise level infrastructure that can power any LLM production use cases. Here are some use cases for BricksLLM: * Set LLM usage limits for users on different pricing tiers * Track LLM usage on a per user and per organization basis * Block or redact requests containing PIIs * Improve LLM reliability with failovers, retries and caching * Distribute API keys with rate limits and cost limits for internal development/production use cases * Distribute API keys with rate limits and cost limits for students

github
: 953
uAgents Screenshot
uAgents

uAgents is a Python library developed by Fetch.ai that allows for the creation of autonomous AI agents. These agents can perform various tasks on a schedule or take action on various events. uAgents are easy to create and manage, and they are connected to a fast-growing network of other uAgents. They are also secure, with cryptographically secured messages and wallets.

github
: 1.3k
griptape Screenshot
griptape

Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step. Griptape's core components include Structures (Agents, Pipelines, and Workflows), Tasks, Tools, Memory (Conversation Memory, Task Memory, and Meta Memory), Drivers (Prompt and Embedding Drivers, Vector Store Drivers, Image Generation Drivers, Image Query Drivers, SQL Drivers, Web Scraper Drivers, and Conversation Memory Drivers), Engines (Query Engines, Extraction Engines, Summary Engines, Image Generation Engines, and Image Query Engines), and additional components (Rulesets, Loaders, Artifacts, Chunkers, and Tokenizers). Griptape enables developers to create AI-powered applications with ease and efficiency.

github
: 2.1k