MaverickMCP

https://github.com/wshobson/maverick-mcp
Admin
MaverickMCP is a FastMCP server that provides professional-grade financial data analysis, technical...
Tokens:109,376
Snippets:895
Trust Score:9.6
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Run Interactive Examples

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Launches guided examples and tutorials for using the Tiingo data loader. This script provides an interactive way to learn and experiment with the loader's features.

```bash
# Run guided examples
python3 scripts/load_example.py
```

--------------------------------

### Start MaverickMCP Server

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

This snippet shows different methods to start the MaverickMCP FastAPI server. It includes using the provided `Makefile`, running the server directly via Python module execution, and using a development script for hot reloading.

```bash
# Recommended: Use the Makefile
make dev

# Alternative: Direct FastMCP server
python -m maverick_mcp.api.server --transport streamable-http --port 8003

# Development mode with hot reload
./scripts/dev.sh
```

--------------------------------

### Verify Setup Completion

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Re-runs the setup validation script after installing dependencies and configuring environment variables to confirm that all components are correctly set up and ready for use. A success message indicates completion.

```bash
python3 scripts/validate_setup.py
```

--------------------------------

### Starting MaverickMCP Server

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

Commands to start the MaverickMCP server for remote connection. It includes using a Makefile target for development or manually running the server with Uvicorn.

```bash
# Start the server
make dev

# Or manually
uvicorn maverick_mcp.api.server:app --host 0.0.0.0 --port 8003
```

--------------------------------

### Development Setup

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Initiates the development environment for MaverickMCP. This command typically handles dependency installation and setup. The `uv sync` command ensures dependencies are managed by uv.

```bash
uv sync
make dev
```

--------------------------------

### PostgreSQL Database Setup and Migration

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

Instructions for configuring and setting up the database for PostgreSQL. This involves setting the DATABASE_URL environment variable, creating the PostgreSQL database, and running the database migration script.

```bash
# Set environment variable
export DATABASE_URL=postgresql://localhost/maverick_mcp

# Create PostgreSQL database
createdb maverick_mcp

# Run migration
python scripts/migrate_db.py
```

--------------------------------

### Manual Step-by-Step Database Setup

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

Provides manual steps to set up the database using Python scripts. This includes migrating the database to create tables, seeding the database with sample data, and testing the seeded data. No API key is required for seeding.

```python
# Step 1: Create database tables
python scripts/migrate_db.py

# Step 2: Seed with sample data (no API key required)
python scripts/seed_db.py

# Step 3: Test the setup
python scripts/test_seeded_data.py
```

--------------------------------

### Custom Workflow Example (Python)

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Provides an example of a custom workflow in Python that loads market data using `TiingoDataLoader` and then performs custom analysis using the database session. This demonstrates integrating data loading with subsequent data processing.

```python
# Example: Load data then run custom analysis
from scripts.load_tiingo_data import TiingoDataLoader
from maverick_mcp.data.models import SessionLocal

async with TiingoDataLoader() as loader:
    await loader.load_symbol_data("AAPL", "2023-01-01")

with SessionLocal() as session:
    # Your custom analysis here
    pass
```

--------------------------------

### Development Data Loading Practices

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Demonstrates best practices for loading data during development, emphasizing starting with smaller datasets and using checkpoints for efficient testing and iteration. This includes specifying fewer years and smaller batch sizes.

```bash
# Start small for testing
python3 scripts/load_tiingo_data.py --symbols AAPL,MSFT --years 0.5 --batch-size 10

# Use checkpoints for large loads
python3 scripts/load_tiingo_data.py --sp500 --checkpoint-file dev_progress.json
```

--------------------------------

### Python Example for Installing Dependencies

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/exa_research_testing_strategy.md

Provides commands to install project dependencies, addressing potential 'ImportError: No module named 'exa_py''. It suggests using either `uv sync` or `pip install -e .`.

```bash
uv sync
# or
pip install -e .
```

--------------------------------

### Clone MaverickMCP and Install Dependencies

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

This snippet demonstrates how to clone the MaverickMCP repository from GitHub and install its Python dependencies using either 'uv' (recommended) or 'pip'. Ensure Python 3.12+ is installed.

```bash
# Clone the repository
git clone https://github.com/wshobson/maverick-mcp.git
cd maverick-mcp

# Install dependencies using uv (recommended)
uv sync

# Or use pip
pip install -e .
```

--------------------------------

### Start Maverick-MCP Server using Makefile

Source: https://github.com/wshobson/maverick-mcp/blob/main/maverick_mcp/README.md

This command utilizes the Makefile to initiate the development environment for the Maverick-MCP server. It is the recommended method for starting the server in a development context, likely handling setup and dependencies.

```bash
make dev
```

--------------------------------

### Verify MaverickMCP Setup

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

This snippet provides commands to verify that the MaverickMCP server is running correctly. It includes checking the health endpoint using `curl` and testing a simple query using `nc` (netcat) for streamable-http transport, as well as a direct API call example.

```bash
# Check health endpoint
curl http://localhost:8003/health

# Test a simple query (if using MCP client)
echo '{"method": "tools/list"}' | nc localhost 8003

# Or use the API directly
curl http://localhost:8003/api/data/stock/AAPL
```

--------------------------------

### Interact with MCP API using Curl

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

Examples of using `curl` to interact with the Maverick MCP API. These commands demonstrate how to list available tools and call a specific tool like `get_maverick_stocks`.

```bash
# List available tools
curl -X POST http://localhost:8003/mcp \
    -H "Content-Type: application/json" \
    -d '{"method": "tools/list"}'

# Get screening results
curl -X POST http://localhost:8003/mcp \
    -H "Content-Type: application/json" \
    -d '{ 
        "method": "tools/call", 
        "params": { 
            "name": "get_maverick_stocks", 
            "arguments": {"limit": 10}
        }
    }'
```

--------------------------------

### Validate Setup Script

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Executes a script to check your current environment setup and identify any missing dependencies or configuration requirements for the Tiingo data loader. This is the first step to ensure a successful installation.

```bash
cd /path/to/maverick-mcp
python3 scripts/validate_setup.py
```

--------------------------------

### Complete Database Setup Script

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

Executes a shell script to create the SQLite database, seed it with sample stock data, populate price records, generate screening results, and add technical indicators cache. Assumes default SQLite configuration.

```bash
# Set your database URL (optional - defaults to SQLite)
export DATABASE_URL=sqlite:///maverick_mcp.db

# Run the complete setup script
./scripts/setup_database.sh
```

--------------------------------

### Configure Database Connection

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Sets up the database connection string for storing the fetched and processed data. This example uses a PostgreSQL database. Ensure your database is running and accessible.

```bash
# Set your database URL
export DATABASE_URL=postgresql://user:password@localhost/maverick_mcp

# Or use existing environment variables
export POSTGRES_URL=postgresql://user:password@localhost/maverick_mcp
```

--------------------------------

### Troubleshooting: OpenRouter API Key Setup

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Guides users on troubleshooting OpenRouter integration issues. Requires setting the `OPENROUTER_API_KEY` in the `.env` file and checking its validity on the OpenRouter website. Mentions fallback to direct providers.

```bash
Ensure OPENROUTER_API_KEY is set in .env
Check API key validity at [openrouter.ai](https://openrouter.ai)
System falls back to direct providers if OpenRouter unavailable
```

--------------------------------

### Mount Router and Client Test (Python)

Source: https://github.com/wshobson/maverick-mcp/blob/main/maverick_mcp/tests/README_INMEMORY_TESTS.md

Example of mounting a specific router ('technical_router') onto a test MCP instance and then using the FastMCP client to test only that router.

```python
test_mcp = FastMCP("TestServer")
test_mcp.mount("/technical", technical_router)
async with Client(test_mcp) as client:
    # Test only technical router
```

--------------------------------

### Starting the MaverickMCP Server

Source: https://context7.com/wshobson/maverick-mcp/llms.txt

Instructions on how to launch the MaverickMCP server using different transport protocols. It covers Make commands for development environments and direct Python execution with customization options. Includes a command to check if the server is running and how to follow logs.

```bash
make dev
# Or explicitly: make dev-sse
# Server starts on http://localhost:8003/sse

make dev-http
# Server starts on http://localhost:8003/mcp/

make dev-stdio

uv run python -m maverick_mcp.api.server --transport sse --port 8003 --host 0.0.0.0

lsof -i :8003

make tail-log
```

--------------------------------

### Set Up Environment Variables

Source: https://github.com/wshobson/maverick-mcp/blob/main/CONTRIBUTING.md

Steps to copy the example environment file and edit it for local configuration. This file contains sensitive information and application settings.

```bash
cp .env.example .env
# Edit .env with your configuration
```

--------------------------------

### Configure Local Database URL

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

Examples of MCP_DATABASE_URL configurations for using SQLite or PostgreSQL locally. SQLite is recommended for simplicity, while PostgreSQL offers better performance.

```bash
# Use SQLite for simplicity
MCP_DATABASE_URL=sqlite:///maverick_mcp.db

# Or PostgreSQL for better performance
MCP_DATABASE_URL=postgresql://user:password@localhost/maverick_mcp
```

--------------------------------

### Starting the MCP Server

Source: https://context7.com/wshobson/maverick-mcp/llms.txt

Instructions on how to launch the MaverickMCP server using different transport protocols and configurations.

```APIDOC
## Starting the MCP Server

Launch the server with different transport protocols for various use cases.

```bash
# Start with SSE transport (recommended for Claude Desktop)
make dev
# Or explicitly: make dev-sse
# Server starts on http://localhost:8003/sse

# Start with HTTP streamable transport (for testing/debugging)
make dev-http
# Server starts on http://localhost:8003/mcp/

# Start with STDIO transport (direct connection)
make dev-stdio

# Alternative: Direct Python execution with custom port
uv run python -m maverick_mcp.api.server --transport sse --port 8003 --host 0.0.0.0

# Check server is running
lsof -i :8003

# Follow server logs in real-time
make tail-log
```
```

--------------------------------

### Run Interactive Examples

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/README_TIINGO_LOADER.md

Command to execute interactive examples provided by the project. These examples demonstrate various functionalities such as loading sample stocks, sector stocks, and resuming interrupted loads.

```bash
python scripts/load_example.py
```

--------------------------------

### Resume Data Loading from Checkpoint

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

Provides bash commands to start or resume data loading for the Tiingo API. The loader saves progress to a checkpoint file, allowing interrupted loads to be resumed.

```bash
# Start loading (creates checkpoint file)
python scripts/load_tiingo_data.py --sp500 --years 2

# If interrupted, resume from checkpoint
python scripts/load_tiingo_data.py --resume
```

--------------------------------

### Set Date Range for Data Loading

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Specifies the historical data range for loading. You can either define the number of years to fetch or provide a specific start date. This allows for flexible data retrieval based on your analysis needs.

```bash
# Date Range: --years 5 or --start-date 2020-01-01
```

--------------------------------

### Tiingo Configuration Example

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/README_TIINGO_LOADER.md

Demonstrates how to configure the Tiingo data loader for different environments, such as production. It shows importing configuration settings and retrieving environment-specific parameters.

```python
from scripts.tiingo_config import TiingoConfig, get_config_for_environment

# Get environment-specific config
config = get_config_for_environment('production')
```

--------------------------------

### Install Python Dependencies

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Installs the necessary Python packages required for the Tiingo data loader. This can be done using a requirements file or by installing packages individually. Ensure you have Python 3 and pip installed.

```bash
# Install required Python packages
pip install -r scripts/requirements_tiingo.txt

# Or install individually:
pip install aiohttp pandas pandas-ta sqlalchemy psycopg2-binary
```

--------------------------------

### Install Missing Dependencies

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Installs missing Python dependencies required for the Tiingo data loader, typically by installing packages listed in a requirements file. This is a common solution for 'ModuleNotFoundError'.

```bash
# Error: ModuleNotFoundError: No module named 'aiohttp'
pip install -r scripts/requirements_tiingo.txt
```

--------------------------------

### Load Initial Financial Data into MaverickMCP

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

These snippets show various ways to load initial financial data into MaverickMCP using the `load_tiingo_data.py` script. Options include loading the top 10 S&P 500 stocks, the full S&P 500, or custom symbols with specific date ranges. All options include calculating indicators and running screening.

```bash
# Option A: Quick Start (Top 10 S&P 500)
# Load 2 years of data for top 10 S&P 500 stocks
python scripts/load_tiingo_data.py \
    --symbols AAPL MSFT GOOGL AMZN NVDA META TSLA LLY V UNH \
    --years 2 \
    --calculate-indicators \
    --run-screening
```

```bash
# Option B: Full S&P 500
# Load S&P 500 stocks with screening
python scripts/load_tiingo_data.py \
    --sp500 \
    --years 2 \
    --calculate-indicators \
    --run-screening
```

```bash
# Option C: Custom Symbols
# Load specific symbols with custom date range
python scripts/load_tiingo_data.py \
    --symbols AAPL MSFT GOOGL \
    --start-date 2022-01-01 \
    --end-date 2024-01-01 \
    --calculate-indicators \
    --run-screening
```

--------------------------------

### Running Make Commands for Development

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

A set of make commands to manage development processes, including starting services, stopping them, viewing logs, and running tests.

```bash
make tail-log          # View server logs
make stop              # Stop services if ports are in use
make clean             # Clean up cache files
make dev               # Start everything
make test              # Run tests quickly
make experiment        # Test custom analysis scripts
```

--------------------------------

### New Feature Test Example (Python)

Source: https://github.com/wshobson/maverick-mcp/blob/main/maverick_mcp/tests/README_INMEMORY_TESTS.md

An example of an asynchronous test case for a new feature. It utilizes fixtures (`test_db`, `mock_redis`), makes a tool call, and asserts the structure and content of the returned data.

```python
@pytest.mark.asyncio
async def test_new_feature(test_db, mock_redis):
    """Test description."""
    async with Client(mcp) as client:
        result = await client.call_tool("new_tool", {
            "param": "value"
        })
        
        assert result.text is not None
        data = eval(result.text)
        assert data["expected_key"] == "expected_value"
```

--------------------------------

### Bash Commands for Speed Benchmarking Script

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/speed_testing_framework.md

Provides example command-line invocations for the `speed_benchmark.py` script, demonstrating various modes of operation such as quick validation, full benchmarking, emergency scenario testing, performance comparison, and custom query execution. This is useful for running benchmarks manually or in automated scripts.

```bash
# Quick validation for CI pipeline
python scripts/speed_benchmark.py --mode quick

# Comprehensive benchmark suite
python scripts/speed_benchmark.py --mode full

# Emergency mode focused testing
python scripts/speed_benchmark.py --mode emergency

# Before/after performance comparison
python scripts/speed_benchmark.py --mode comparison

# Custom query testing
python scripts/speed_benchmark.py --query "Apple Inc analysis"
```

--------------------------------

### Run All In-Memory Tests (Bash)

Source: https://github.com/wshobson/maverick-mcp/blob/main/maverick_mcp/tests/README_INMEMORY_TESTS.md

Executes all test files starting with 'test_in_memory' using pytest.

```bash
pytest maverick_mcp/tests/test_in_memory*.py -v
```

--------------------------------

### Install Maverick-MCP with uv

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Clones the Maverick-MCP repository and installs dependencies along with creating a virtual environment using the uv package manager. This is the recommended installation method.

```bash
git clone https://github.com/wshobson/maverick-mcp.git
cd maverick-mcp
uv sync
cp .env.example .env
# Add your Tiingo API key (free at tiingo.com)
```

--------------------------------

### Install TA-Lib on Windows via Pip (Pre-compiled Package)

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Installs the TA-Lib library on Windows using a pre-compiled package available through pip. This offers a simpler installation than building from source or managing wheel files manually.

```bash
pip install TA-Lib-Precompiled
```

--------------------------------

### Production Data Loading Best Practices

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Outlines best practices for running data loads in a production environment, focusing on performance optimization with larger batch sizes and concurrent requests, as well as scheduling regular updates using cron jobs.

```bash
# Higher performance settings
python3 scripts/load_tiingo_data.py --sp500-full \
    --batch-size 100 \
    --max-concurrent 10 \
    --years 2 \
    --run-screening

# Schedule regular updates
# Add to crontab: 0 18 * * 1-5 /path/to/load_script.sh
```

--------------------------------

### Caching Configuration: Redis

Source: https://github.com/wshobson/maverick-mcp/blob/main/CLAUDE.md

Set up Redis for improved caching performance. This involves installing and starting the Redis service, which the server will automatically detect and utilize.

```bash
# Install and start Redis
brew install redis
brew services start redis

# Or use make command
make redis-start
```

--------------------------------

### Install TA-Lib on Windows via Pip with Pre-compiled Wheel

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Installs the TA-Lib library on Windows by downloading a pre-compiled wheel file specific to your Python version and then installing it using pip. This method requires manually finding the correct wheel file.

```bash
pip install path/to/downloaded/TA_Lib-X.X.X-cpXXX-cpXXX-win_amd64.whl
```

--------------------------------

### Load Single Symbol for Testing

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

A bash command to load data for a single stock symbol, which is useful for testing the data loading and indicator calculation pipeline.

```bash
python scripts/load_tiingo_data.py \
    --symbols AAPL \
    --years 1 \
    --calculate-indicators
```

--------------------------------

### Start Development Server

Source: https://github.com/wshobson/maverick-mcp/blob/main/CONTRIBUTING.md

Commands to start the development server for MaverickMCP. The `make dev` command is recommended for a comprehensive startup.

```bash
make dev
# Or: ./scripts/start-backend.sh --dev
```

--------------------------------

### Troubleshooting Server Start Issues

Source: https://github.com/wshobson/maverick-mcp/blob/main/CLAUDE.md

Commands to stop, clean, and restart the development server to resolve startup problems. This sequence helps ensure a clean state for the application.

```bash
make stop          # Stop any running processes
make clean         # Clean temporary files
make dev           # Restart
```

--------------------------------

### Configure Redis Caching

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

Environment variables for enabling and configuring Redis caching. This section outlines how to activate caching, set the time-to-live, and specify Redis connection details.

```bash
CACHE_ENABLED=true
CACHE_TTL_SECONDS=300
REDIS_HOST=localhost
REDIS_PORT=6379
```

--------------------------------

### Set SQLite Database for Testing

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

Configures the MCP_DATABASE_URL environment variable to use an SQLite database for testing purposes. This is a simpler alternative to setting up a full PostgreSQL instance.

```bash
# Use SQLite for testing
export MCP_DATABASE_URL=sqlite:///test.db
```

--------------------------------

### Environment Variables for MaverickMCP

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

Lists essential environment variables for configuring MaverickMCP, including database connection URL, logging level, and optional Redis caching settings.

```bash
# Database
DATABASE_URL=sqlite:///maverick_mcp.db

# Optional: Enable debug logging
LOG_LEVEL=debug

# Optional: Redis caching
REDIS_HOST=localhost
REDIS_PORT=6379
```

--------------------------------

### Create and Load Custom Symbol List for Growth Stocks

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/README_TIINGO_LOADER.md

This example shows how to create a text file containing a list of growth stocks and then use it to load data and run screening. This allows for targeted data processing based on specific criteria.

```bash
# Create growth stock list
cat > growth_stocks.txt << EOF
TSLA
NVDA
AMZN
GOOGL
META
NFLX
CRM
ADBE
EOF

# Load growth stocks
python scripts/load_tiingo_data.py --file growth_stocks.txt --run-screening
```

--------------------------------

### Troubleshooting MCP Server Health and Capabilities

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

Shell commands using cURL to check the health of the MaverickMCP server and its capabilities endpoint, confirming the server is running and accessible.

```bash
# Check server is running
curl http://localhost:8003/health

# Check MCP endpoint
curl http://localhost:8003/mcp/capabilities
```

--------------------------------

### Install uv via pip

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Installs the uv package manager using pip, a traditional Python package installer. This serves as an alternative installation method.

```bash
pip install uv
```

--------------------------------

### Claude Desktop Integration Commands

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/api/backtesting.md

Examples of commands for using the Maverick MCP project through Claude Desktop, covering basic backtesting, strategy comparison, intelligent analysis, portfolio backtesting, optimization, and ML strategy training.

```text
# Basic backtest
"Run a backtest for AAPL using RSI strategy with 14-day period"

# Strategy comparison
"Compare SMA crossover, RSI, and MACD strategies on Tesla stock"

# Intelligent analysis
"Run intelligent backtest on Microsoft stock and recommend the best strategy"

# Portfolio backtest
"Backtest momentum strategy on AAPL, MSFT, GOOGL, AMZN, and TSLA"

# Optimization
"Optimize MACD parameters for Netflix stock over the last 2 years"

# ML strategies
"Train an ML predictor on Amazon stock and test its performance"
```

--------------------------------

### Troubleshooting Screening Results Count

Source: https://github.com/wshobson/maverick-mcp/blob/main/DATABASE_SETUP.md

A SQL query to verify if the database was properly seeded by checking the counts of stocks, price cache records, and Maverick stock recommendations.

```sql
SELECT
  (SELECT COUNT(*) FROM mcp_stocks) as stocks,
  (SELECT COUNT(*) FROM mcp_price_cache) as prices,
  (SELECT COUNT(*) FROM mcp_maverick_stocks) as maverick;
```

--------------------------------

### Load Stocks from a File

Source: https://github.com/wshobson/maverick-mcp/blob/main/scripts/INSTALLATION_GUIDE.md

Loads stock symbols from a text file, calculates technical indicators, and runs screening algorithms. This provides flexibility for loading custom watchlists.

```bash
# Create symbol file
echo -e "AAPL\nMSFT\nGOOGL\nTSLA\nNVDA" > my_stocks.txt

# Load from file
python3 scripts/load_tiingo_data.py --file my_stocks.txt --calculate-indicators --run-screening
```

--------------------------------

### Test PostgreSQL Database Connection

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

A bash command to test the connection to a PostgreSQL database using the psql client. It attempts to execute a simple query to verify connectivity and authentication.

```bash
# Test PostgreSQL connection
psql -U user -d maverick_mcp -c "SELECT 1;"
```

--------------------------------

### Docker Build and Run Commands

Source: https://github.com/wshobson/maverick-mcp/blob/main/README.md

Provides bash commands for building a Docker image for the Maverick MCP project and running it in a container. Includes instructions for environment variable configuration and using `docker-compose`.

```bash
# Copy and configure environment
cp .env.example .env

# Using uv in Docker (recommended for faster builds)
docker build -t maverick_mcp .
docker run -p 8003:8003 --env-file .env maverick_mcp

# Or start with docker-compose
docker-compose up -d
```

--------------------------------

### Run MaverickMCP Database Migrations with Alembic

Source: https://github.com/wshobson/maverick-mcp/blob/main/docs/SETUP_SELF_CONTAINED.md

This snippet demonstrates how to initialize and run database migrations for MaverickMCP using Alembic. It covers initializing Alembic, applying all pending migrations, and checking the current migration status. This process creates the self-contained tables prefixed with `mcp_`.

```bash
# Initialize Alembic (if not already done)
alembic init alembic

# Run all migrations to create schema
alembic upgrade head

# Verify migration
alembic current
```
Tokens:
Raw