@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/site/use-cases/cli-ai-workflows.md

@@ -0,0 +1,285 @@
+# Using Probe in the CLI for Advanced AI
+
+This guide explains how to use Probe's CLI-based AI chat capabilities for powerful code exploration and understanding directly from your terminal.
+
+## Overview
+
+Probe's AI Chat mode combines the power of large language models with Probe's code search capabilities, all in a convenient command-line interface. This integration allows you to have natural conversations about your codebase without leaving your terminal.
+
+Key benefits:
+
+- **Natural Language Understanding**: Ask questions about your code in plain English
+- **Contextual Awareness**: The AI maintains conversation history for follow-up questions
+- **Code-Aware Responses**: Get explanations that reference specific files and line numbers
+- **Intelligent Search**: The AI automatically formulates optimal search queries based on your questions
+- **Local Search Engine**: Probe searches your code locally without requiring embedding generation, but search results are sent to the AI service
+
+## Getting Started
+
+### Quick Setup
+
+The fastest way to get started is using npx:
+
+```bash
+# Set your API key first
+export ANTHROPIC_API_KEY=your_api_key
+# Or for OpenAI
+# export OPENAI_API_KEY=your_api_key
+
+# Run directly with npx (no installation needed)
+npx -y @probelabs/probe-chat@latest
+
+# Or specify a directory to search
+npx -y @probelabs/probe-chat@latest /path/to/your/project
+```
+
+### Global Installation
+
+For regular use, you might prefer a global installation:
+
+```bash
+# Install globally
+npm install -g @probelabs/probe-chat@latest
+
+# Start the chat interface
+probe-chat
+```
+
+## Common Workflows
+
+### 1. Exploring a New Codebase
+
+When you're new to a project, the AI chat can help you quickly understand its structure and functionality:
+
+```
+❯ What's the overall architecture of this project?
+
+❯ What are the main components and how do they interact?
+
+❯ How is data flowing through the system?
+```
+
+### 2. Understanding Complex Code
+
+When you encounter complex code that's difficult to understand:
+
+```
+❯ Can you explain how the ranking algorithm in src/ranking.rs works?
+
+❯ What's the purpose of the cache implementation in the search module?
+
+❯ Walk me through the authentication flow step by step.
+```
+
+### 3. Finding Implementation Details
+
+When you need to locate specific functionality:
+
+```
+❯ Where is the error handling implemented for API requests?
+
+❯ How does the system validate user input?
+
+❯ Show me all the places where database connections are created.
+```
+
+### 4. Learning Best Practices
+
+When you want to understand the patterns and practices used in the codebase:
+
+```
+❯ What design patterns are used in this project?
+
+❯ How is testing implemented across the codebase?
+
+❯ What's the error handling strategy used in this project?
+```
+
+### 5. Planning Changes
+
+When you need to make changes to the codebase:
+
+```
+❯ If I wanted to add a new authentication method, what files would I need to modify?
+
+❯ What would be the impact of changing the database schema for users?
+
+❯ How could I improve the performance of the search functionality?
+```
+
+## Advanced Configuration
+
+### Model Selection
+
+You can choose which AI model to use:
+
+```bash
+# Override the default model
+export MODEL_NAME=claude-3-opus-20240229
+probe-chat
+```
+
+### API URLs
+
+For enterprise deployments or when using proxies:
+
+```bash
+# Override API URLs
+export ANTHROPIC_API_URL=https://your-anthropic-proxy.com
+export OPENAI_API_URL=https://your-openai-proxy.com/v1
+probe-chat
+```
+
+### Debug Mode
+
+For troubleshooting or development:
+
+```bash
+# Enable debug mode for detailed logging
+export DEBUG=1 probe-chat
+```
+
+### Session-Based Caching
+
+Probe uses session-based caching to avoid showing the same code blocks multiple times in a conversation:
+
+```bash
+# First search generates a session ID
+probe search "authentication" --session ""
+# Session: a1b2 (example output)
+
+# Subsequent searches reuse the session ID
+probe search "login" --session "a1b2"
+# Will skip code blocks already shown in the previous search
+```
+
+## Integration with Other CLI Tools
+
+Probe's AI chat can be combined with other command-line tools for even more powerful workflows:
+
+### Piping Compiler Errors
+
+Feed compiler errors directly to the AI for explanation:
+
+```bash
+# Compile and pipe errors to AI chat
+rustc main.rs 2>&1 | probe-chat
+```
+
+### Using Extract with LLM Prompts
+
+Extract code with built-in prompt templates for LLM integration:
+
+```bash
+# Extract with engineer prompt template
+probe extract src/auth.rs#authenticate --prompt engineer --instructions "Explain this authentication function"
+
+# Extract with architect prompt template
+probe extract src/api.js --prompt architect --instructions "Analyze this API module"
+
+# Extract and pipe to AI chat
+probe extract src/main.rs:42 --prompt engineer --instructions "Explain this function" | probe-chat
+```
+
+### Processing Search Results
+
+Use standard Unix tools to process search results:
+
+```bash
+# Find then filter
+probe search "database" | grep "connection" | probe-chat
+```
+
+### Scripting with AI Chat
+
+You can create scripts that use the AI chat for automated tasks:
+
+```bash
+#!/bin/bash
+# Example script to analyze code quality
+echo "What are the potential security issues in this codebase?" | probe-chat > security_report.txt
+```
+
+## Best Practices
+
+1. **Be Specific**: Ask specific questions about your codebase for more targeted answers
+
+2. **Start with Overview Questions**: Begin with high-level questions to understand the structure before diving into details
+
+3. **Follow Up**: Use follow-up questions to explore topics in more depth
+
+4. **Reference Files**: Mention specific files or directories if you want to focus on a particular area
+
+5. **Ask for Explanations**: The AI is particularly good at explaining complex code or concepts
+
+6. **Request Examples**: Ask for examples if you're trying to understand how to use a particular feature or API
+
+7. **Use Multiple Queries**: If you don't find what you're looking for, try reformulating your question
+
+8. **Combine with Regular CLI**: Use the AI chat alongside regular Probe CLI commands for maximum effectiveness
+
+## Example Conversation
+
+Here's an example of how you might use the AI Chat mode:
+
+```
+❯ 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)
+─────────────────────────────────────────────────────────────────────
+```
+
+## Limitations and Considerations
+
+- **Token Limits**: Very large codebases may need multiple targeted questions rather than broad ones
+- **API Costs**: Be mindful of token usage, especially with larger models
+- **Privacy**: When using Probe with AI services, code snippets found by Probe are sent to external AI providers (Anthropic, OpenAI, etc.) as part of your queries
+- **Accuracy**: The AI may occasionally make mistakes in its understanding or explanations
+
+## Next Steps
+
+- Learn about [Probe's CLI Reference](/cli-mode) for more advanced command-line usage
+- Explore [using Probe with AI Code Editors](/use-cases/ai-code-editors) for integrated IDE experiences
+- Check out [building custom tools](/use-cases/nodejs-sdk) with the Node.js SDK

package/data/probe/site/use-cases/deploying-probe-web-interface.md

@@ -0,0 +1,255 @@
+# Centralized Code Search: Deploying the Probe Web Interface
+
+This guide explains how to set up and deploy Probe's web interface as a centralized code search and intelligence platform for your entire organization.
+
+## Overview
+
+Probe's web interface provides a user-friendly chat experience that allows all team members to interact with your codebase using AI. By hosting this interface, you create a source of truth for how your product works that's accessible to both technical and non-technical team members. This enables quick issue resolution, documentation generation, architecture understanding, and helps product managers, QA teams, and other stakeholders make informed decisions without needing to understand implementation details.
+
+
+## Quick Setup with npx
+
+The easiest way to deploy Probe's web interface for a team is using npx:
+
+```bash
+# Set your API key first (either Anthropic or OpenAI)
+export ANTHROPIC_API_KEY=your_anthropic_api_key
+# OR
+export OPENAI_API_KEY=your_openai_api_key
+
+# Configure allowed folders (required)
+export ALLOWED_FOLDERS=/path/to/repo1,/path/to/repo2
+
+# Enable authentication for team use
+export AUTH_ENABLED=true
+export AUTH_USERNAME=team
+export AUTH_PASSWORD=secure_password
+
+# Run the web interface
+npx -y @probelabs/probe-chat@latest --web
+```
+
+### Access the Web Interface
+
+Once the server is running, team members can access the web interface at:
+
+```
+http://your-server-ip:8080
+```
+
+You can customize the port using the `--port` option:
+
+```bash
+npx -y @probelabs/probe-chat@latest --web --port 3000
+```
+
+## Setting Allowed Folders (Security & Privacy)
+
+Controlling which code repositories are accessible is crucial for security:
+
+### Configuring Allowed Folders
+
+```bash
+# Specify which folders can be searched
+export ALLOWED_FOLDERS=/path/to/repo1,/path/to/repo2,/path/to/repo3
+```
+
+This environment variable:
+- Restricts search to only the specified directories
+- Prevents access to sensitive files outside these directories
+- Can include multiple repositories separated by commas
+
+### Best Practices for Folder Access
+
+1. **Use Absolute Paths**: Always use full paths to avoid ambiguity
+2. **Limit Scope**: Only include repositories that should be accessible
+3. **Exclude Sensitive Directories**: Don't include directories with secrets or sensitive data
+4. **Consider Read-Only Access**: For additional security, consider setting up read-only filesystem permissions for the user running the service
+
+## Managing API Keys for the Chat
+
+The web interface requires an API key for either Anthropic Claude or OpenAI:
+
+### API Key Management
+
+```bash
+# For Anthropic Claude (recommended)
+export ANTHROPIC_API_KEY=your_anthropic_api_key
+
+# OR for OpenAI
+export OPENAI_API_KEY=your_openai_api_key
+```
+
+### Best Practices for API Keys
+
+1. **Use Environment Variables**: Never hardcode API keys in files
+2. **Rotate Keys Regularly**: Change keys periodically for security
+3. **Monitor Usage**: Keep track of API usage to control costs
+4. **Use a Secrets Manager**: For production deployments, consider using a secrets manager
+
+### Model Selection
+
+You can specify which AI model to use:
+
+```bash
+# For Anthropic Claude
+export MODEL_NAME=claude-3-opus-20240229
+
+# For OpenAI
+export MODEL_NAME=gpt-4o
+```
+
+## Authentication & Environment Variables
+
+Secure your deployment with authentication:
+
+### Enabling Authentication
+
+```bash
+# Enable basic authentication
+export AUTH_ENABLED=true
+export AUTH_USERNAME=your_username
+export AUTH_PASSWORD=your_secure_password
+```
+
+### Complete Environment Variable Reference
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ANTHROPIC_API_KEY` | Your Anthropic API key | (Required if not using OpenAI) |
+| `OPENAI_API_KEY` | Your OpenAI API key | (Required if not using Anthropic) |
+| `ALLOWED_FOLDERS` | Comma-separated list of folders to search | (Required) |
+| `PORT` | The port to run the server on | 8080 |
+| `MODEL_NAME` | Override the default model | claude-3-7-sonnet-latest or gpt-4o |
+| `AUTH_ENABLED` | Enable basic authentication | false |
+| `AUTH_USERNAME` | Username for authentication | admin |
+| `AUTH_PASSWORD` | Password for authentication | password |
+| `DEBUG` | Enable debug mode | false |
+
+
+## Command-Line Options
+
+The web interface supports the following command-line options:
+
+```bash
+# Show help
+npx -y @probelabs/probe-chat@latest --help
+
+# Run in web mode on a specific port
+npx -y @probelabs/probe-chat@latest --web --port 3000
+
+# Specify a model
+npx -y @probelabs/probe-chat@latest --web --model claude-3-7-sonnet-latest
+
+# Enable debug mode
+npx -y @probelabs/probe-chat@latest --web --debug
+
+# Specify a directory to search
+npx -y @probelabs/probe-chat@latest --web /path/to/your/project
+```
+
+### Using the npm package (Alternative)
+
+If you prefer, you can install the package globally:
+
+```bash
+# Install globally
+npm install -g @probelabs/probe-chat@latest
+
+# Start the web interface
+probe-chat --web --port 3000
+```
+
+## Best Practices for Organization-Wide Usage
+
+### Cross-Functional Team Onboarding
+
+1. **Create Role-Specific Documentation**: Tailor guides for different roles (developers, product managers, QA)
+2. **Provide Example Queries**: Share effective prompts and questions for common use cases
+3. **Set Usage Guidelines**: Establish best practices for different types of searches
+4. **Training Sessions**: Conduct role-specific training for technical and non-technical users
+5. **Highlight Business Benefits**: Demonstrate how code search improves collaboration and knowledge sharing
+
+### Performance Optimization
+
+1. **Limit Repository Size**: Include only necessary repositories
+2. **Use a Powerful Server**: Ensure adequate CPU and memory
+3. **Consider SSD Storage**: Faster disk access improves search performance
+4. **Regular Maintenance**: Keep the package and Node.js updated
+
+### Security Considerations
+
+1. **Network Security**: Use a reverse proxy with HTTPS
+2. **IP Restrictions**: Limit access to your company network
+3. **Regular Updates**: Keep the software updated
+4. **Audit Logs**: Monitor access and usage
+
+### Example Nginx Configuration
+
+```nginx
+server {
+    listen 443 ssl;
+    server_name code-chat.yourcompany.com;
+
+    ssl_certificate /path/to/cert.pem;
+    ssl_certificate_key /path/to/key.pem;
+
+    location / {
+        proxy_pass http://localhost:8080;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        
+        # Rate limiting
+        limit_req zone=one burst=10 nodelay;
+    }
+}
+```
+
+## Cloud Deployment Options
+
+For teams working remotely:
+
+### Virtual Private Server (VPS)
+
+1. Provision a VPS with adequate resources
+2. Install Node.js (v18 or later)
+3. Set up environment variables for API keys and allowed folders
+4. Run the web interface using npx
+5. Set up a domain name and SSL certificate
+6. Configure a reverse proxy for HTTPS
+
+### Process Management
+
+For production deployments, use a process manager like PM2:
+
+```bash
+# Install PM2
+npm install -g pm2
+
+# Start the web interface with PM2
+pm2 start "npx -y @probelabs/probe-chat@latest --web" --name "probe-web" --env "ANTHROPIC_API_KEY=your_key" "ALLOWED_FOLDERS=/path/to/repos"
+
+# Ensure it starts on system boot
+pm2 startup
+pm2 save
+```
+
+## Monitoring and Maintenance
+
+### Usage Monitoring
+
+1. **API Usage**: Monitor API costs and usage
+2. **Server Resources**: Track CPU, memory, and disk usage
+3. **User Activity**: Monitor access logs and usage patterns
+
+### Regular Updates
+
+1. **Update Package**: Regularly update to the latest version with `npm update -g @probelabs/probe-chat`
+2. **Update Node.js**: Keep Node.js updated to the latest LTS version
+3. **Rotate Credentials**: Change API keys and passwords periodically
+
+## Next Steps
+
+- For individual developer workflows, see [Integrating Probe into AI Code Editors](/use-cases/integrating-probe-into-ai-code-editors)
+- For advanced CLI usage, check out [CLI AI Workflows](/use-cases/advanced-cli)
+- For programmatic access, explore [Building AI Tools on Probe](/use-cases/building-ai-tools)

package/data/probe/site/use-cases/integrating-probe-into-ai-code-editors.md

@@ -0,0 +1,161 @@
+# Integrating Probe into AI Code Editors
+
+This guide explains how to integrate Probe with AI-powered code editors to enhance your coding experience with intelligent code search and understanding.
+
+## Overview
+
+AI code editors and assistants are powerful tools, but they often struggle with large codebases because they can't efficiently search and understand your entire project. Probe solves this problem by providing a specialized code search capability that AI assistants can use to find and understand relevant code.
+
+## Quick Setup
+
+### Installing @probelabs/probe with NPX
+
+The easiest way to integrate Probe with your AI code editor is through the MCP (Model Context Protocol) server:
+
+```bash
+# You don't need to install anything permanently
+# NPX will run the package directly
+npx -y @probelabs/probe@latest mcp
+```
+
+**Migrating from @probelabs/probe-mcp?** This is a drop-in replacement - just replace `npx @probelabs/probe-mcp` with `npx @probelabs/probe mcp`.
+
+This command will:
+1. Download the Probe MCP server package
+2. Automatically download the appropriate Probe binary for your platform
+3. Start the MCP server, which will listen for requests from your AI editor
+
+### Configuring Your AI Editor
+
+#### For Cline
+
+1. Create a `.cline` directory in your project root:
+   ```bash
+   mkdir -p .cline
+   ```
+
+2. Create an MCP configuration file:
+   ```bash
+   # Create the configuration file
+   touch .cline/mcp_config.json
+   ```
+
+3. Add the following configuration to `.cline/mcp_config.json`:
+   ```json
+   {
+     "mcpServers": {
+       "probe": {
+         "command": "npx",
+         "args": [
+           "-y",
+           "@probelabs/probe@latest",
+           "mcp"
+         ]
+       }
+     }
+   }
+   ```
+
+4. Start Cline in your project directory and begin asking questions about your code.
+
+#### For Roo Code
+
+[Roo Code](https://github.com/RooVetGit/Roo-Code) can be configured the same way as other editors via MCP:
+
+1. Follow the installation instructions from the Roo Code GitHub repository
+2. Configure Roo to use Probe via MCP using the same configuration pattern
+3. Start using Roo with Probe integration
+
+#### For Cursor and Windsurf
+
+1. Install Cursor or Windsurf
+2. Configure the editor to use MCP
+3. Add the Probe MCP server configuration
+4. Restart the editor to apply changes
+
+#### For Other AI Assistants
+
+Check your AI editor's documentation for MCP configuration. The general pattern is similar:
+
+1. Find where your editor stores MCP configuration
+2. Add the Probe MCP server configuration
+3. Restart your editor or reload the configuration
+
+## Using Probe with Your AI Editor
+
+Once configured, you can ask your AI assistant questions about your codebase:
+
+- "Find all authentication-related functions in the project"
+- "Show me how error handling is implemented"
+- "Search for code that processes user input"
+
+The AI will use Probe to search your codebase and provide relevant code snippets and explanations.
+
+## Checking Logs and Debugging
+
+If you encounter issues with the integration:
+
+### Enable Debug Mode
+
+```bash
+# Run the MCP server with debug logging
+DEBUG=1 npx -y @probelabs/probe@latest mcp
+```
+
+This will show detailed logs of:
+- Tool calls from the AI
+- Search queries being executed
+- Results being returned
+
+### Common Issues and Solutions
+
+| Issue | Solution |
+|-------|----------|
+| AI doesn't use Probe | Explicitly ask the AI to use Probe: "Using Probe, search for..." |
+| Empty search results | Try a simpler query or check if you're searching in the right directory |
+| MCP server not starting | Check your MCP configuration and ensure npx is installed |
+| Permission errors | Check file permissions on your codebase |
+
+### Verifying the Integration
+
+To verify that the integration is working:
+
+1. Start your AI editor
+2. Ask a question like: "Using Probe, find all functions related to authentication in this project"
+3. Check if the AI responds with relevant code snippets
+4. If not, check the MCP server logs for errors
+
+## Advanced Configuration
+
+For more control over the MCP server:
+
+```json
+{
+  "mcpServers": {
+    "probe": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@probelabs/probe@latest",
+        "mcp"
+      ],
+      "env": {
+        "PROBE_DEFAULT_PATHS": "/path/to/project1,/path/to/project2",
+        "PROBE_MAX_TOKENS": "20000",
+        "DEBUG": "1"
+      }
+    }
+  }
+}
+```
+
+This configuration:
+- Sets default search paths
+- Limits the maximum tokens returned
+- Enables debug logging
+
+## Next Steps
+
+- For advanced MCP usage, see the [MCP Protocol & Tools Reference](/mcp-server)
+- For larger queries or team collaboration, check out the [Web Interface for Teams](/use-cases/team-chat)
+- For CLI-based workflows, explore [Advanced CLI Usage](/use-cases/advanced-cli)