Stealthee MCP

Stealthee MCP - Be Early

Stealthee is a dev-first system for surfacing pre-public product signals - before they trend. It combines search, extraction, scoring, and alerting into a plug-and-play pipeline you can integrate into Claude, LangGraph, Smithery, or your own AI stack via MCP.

What's cookin'?

Core Capabilities

• Web Search: Search across the entire web using Tavily API
• Content Extraction: Extract clean text from URLs using BeautifulSoup
• AI Scoring: AI-powered analysis of signals for stealth launch likelihood
• Batch Processing: Process multiple signals efficiently in parallel
• Tech-Focused Search: Targeted search across tech news sites and Product Hunt
• Field Parsing: Extract structured data like pricing and changelog from HTML
• End-to-End Pipeline: Complete stealth launch detection workflow
• Real-time Alerts: Slack notifications for high-confidence signals
• Database Storage: SQLite storage for all detected signals

MCP Tools

🛠️ Installation

Prerequisites

• Python 3.8+
• API keys for external services (see Environment Variables)

Quick Start

1. Clone and Setup
   git clone https://github.com/rainbowgore/stealthee-MCP-tools cd stealthee-MCP-tools python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt
2. Configure Environment
   cp .env.example .env # Edit .env with your API keys
3. Start MCP Server
   python mcp_server_stdio.py
4. Start FastAPI Server (Optional)
   python start_fastapi.py # Or for Smithery compatibility: ./start_smithery.sh

🔧 Configuration

Environment Variables

Create a .env file with the following variables:

Claude Desktop Integration

Add to your claude_desktop_config.json:

📖 Usage

MCP Server (Claude Desktop)

The MCP server provides tools that can be used directly in Claude Desktop:

1. Search for stealth launches:
   Use web_search to find recent stealth product launches
2. Extract and analyze content:
   Use url_extract to get content from a URL, then score_signal to analyze it
3. Run complete pipeline:
   Use run_pipeline to search, extract, parse, and score signals automatically

FastAPI Server

Access the API at http://localhost:8000:

• API Documentation: http://localhost:8000/docs
• Health Check: http://localhost:8000/health
• Tools List: http://localhost:8000/tools

Example API Usage

🧠 Smithery Integration

This project is natively compatible with Smithery — a local dev UI and workflow runner for MCP tools (Model Context Protocol). If you're building AI pipelines with Claude, LangGraph, or agentic tools, Smithery gives you:

• ✅ Live GUI to test all tools via manifest.json
• ✅ Auto-generated forms from tool schemas
• ✅ Support for Claude Desktop and LangGraph workflows
• ✅ Local tool orchestration + debug view

🔁 To use in Smithery:

🏗️ Architecture

MCP Server (mcp_server_stdio.py)

• Implements Model Context Protocol over stdio
• Provides 7 core tools for stealth detection
• Handles JSON-RPC communication with Claude Desktop
• Includes SQLite database for signal storage

FastAPI Server (fastapi_server.py)

• Exposes MCP tools as HTTP endpoints
• Compatible with Smithery and other AI agent platforms
• Includes request/response logging
• Provides OpenAPI documentation

Tool Schemas (tools/)

• JSON schema definitions for all tools
• Input/output validation
• Example usage patterns

🔬 Signal Intelligence Workflow

1. Search Phase: Use web_search or search_tech_sites to find relevant URLs
2. Extraction Phase: Use url_extract to get clean content from URLs
3. Parsing Phase: Use parse_fields to extract structured data (pricing, changelog, etc.)
4. Analysis Phase: Use score_signal or batch_score_signals for AI-powered analysis
5. Storage Phase: All signals are stored in SQLite database
6. Alert Phase: High-confidence signals trigger Slack notifications

AI Scoring

The system uses OpenAI's API to score signals based on:

• Stealth launch indicators (keywords, timing, context)
• Confidence level (Low/Medium/High)
• Detailed reasoning for the score

📊 Database Schema

Signals are stored in data/signals.db with the following schema:

🧪 Testing

MCP Server Testing

FastAPI Testing

📁 Project Structure

🔧 Development

Adding New Tools

1. Add tool definition to mcp_server_stdio.py
2. Implement handler method
3. Register in execute_tool method
4. Create JSON schema in tools/
5. Add FastAPI endpoint in fastapi_server.py
6. Update Smithery manifest

Dependencies

The project uses minimal, focused dependencies:

• aiohttp - HTTP requests
• beautifulsoup4 - HTML parsing
• openai - AI scoring
• python-dotenv - Environment variables
• fastapi - HTTP API server
• uvicorn - ASGI server
• pydantic - Data validation

📄 License

MIT License - see LICENSE file for details

Support

• Issues: Create an issue on GitHub
• Documentation: Check the API docs at /docs
• Logs: Monitor with ./testing/monitor_logs.sh

Built with 💜 for the builders spotting what others miss