加密货币投资分析系统

# Clone repository
git clone https://github.com/justmy2satoshis/crypto-skills-mcp.git
cd crypto-skills-mcp

# Install with all dependencies
pip install -e ".[all]"

# Or install minimal version
pip install -e .

# Run tests to verify installation
pytest tests/

# Core installation only
pip install -e .

# With skills utilities (pandas, numpy)
pip install -e ".[skills]"

# With agent framework (pydantic, typing-extensions)
pip install -e ".[agents]"

# With development tools (testing, linting, formatting)
pip install -e ".[dev]"

# With testing tools only
pip install -e ".[test]"

# Everything
pip install -e ".[all]"

{
  "mcpServers": {
    "crypto-skills-mcp": {
      "type": "stdio",
      "command": "/path/to/python",
      "args": ["server.py"],
      "cwd": "/path/to/crypto-skills-mcp",
      "env": {
        "MODE": "hybrid",
        "PYTHONUNBUFFERED": "1"
      }
    }
  }
}

cd /path/to/crypto-skills-mcp
python scripts/validate_install.py

                    ┌─────────────────────────────────┐
                    │   ThesisSynthesizer Agent       │
                    │  (Investment Thesis Generation) │
                    │   - Synthesizes multi-agent     │
                    │   - Resolves conflicts          │
                    │   - BUY/HOLD/SELL signals       │
                    └─────────────────────────────────┘
                                  ▲
              ┌───────────────────┼───────────────────┐
              │                   │                   │
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │  CryptoMacro    │ │  CryptoVC       │ │ CryptoSentiment │
    │  Analyst        │ │  Analyst        │ │ Analyst         │
    │                 │ │                 │ │                 │
    │ • Fed policy    │ │ • Tokenomics    │ │ • Fear & Greed  │
    │ • Inst. flows   │ │ • Tech health   │ │ • Social metrics│
    │ • Risk regime   │ │ • Liquidity     │ │ • Whale activity│
    └─────────────────┘ └─────────────────┘ └─────────────────┘
              │                   │                   │
              └───────────────────┼───────────────────┘
                                  ▼
                    ┌─────────────────────────────────┐
                    │      MCP Client Wrapper         │
                    │   (Caching + Error Handling)    │
                    └─────────────────────────────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │  ccxt-mcp       │ │ crypto-indicators│ │ crypto-sentiment│
    │  (Price Data)   │ │ (Technical)      │ │ (Social Metrics)│
    └─────────────────┘ └─────────────────┘ └─────────────────┘

import asyncio
from agents import CryptoMacroAnalyst, CryptoVCAnalyst, CryptoSentimentAnalyst
from mcp_client import MCPClientWrapper

async def analyze_bitcoin():
    # Initialize MCP client wrapper
    mcp_client = MCPClientWrapper()

    # Initialize specialized agents
    macro = CryptoMacroAnalyst(mcp_client=mcp_client)
    vc = CryptoVCAnalyst(mcp_client=mcp_client)
    sentiment = CryptoSentimentAnalyst(mcp_client=mcp_client)

    # Run parallel analysis
    macro_result = await macro.synthesize_macro_outlook("BTC")
    vc_result = await vc.generate_due_diligence_report("BTC")
    sentiment_result = await sentiment.synthesize_sentiment_outlook("bitcoin")

    print(f"Macro Regime: {macro_result['regime']}")
    print(f"Risk Score: {vc_result['overall_score']}/100")
    print(f"Sentiment: {sentiment_result['sentiment_assessment']}")

asyncio.run(analyze_bitcoin())

from agents import ThesisSynthesizer

async def generate_thesis():
    mcp_client = MCPClientWrapper()
    synthesizer = ThesisSynthesizer(mcp_client=mcp_client)

    # Generate complete investment thesis
    thesis = await synthesizer.generate_investment_thesis("BTC", horizon_days=30)

    print(f"Recommendation: {thesis['recommendation']}")
    print(f"Confidence: {thesis['confidence']:.2f}")
    print(f"Entry Range: ${thesis['entry_range']['low']:,.0f} - ${thesis['entry_range']['high']:,.0f}")
    print(f"Position Size: {thesis['position_size'] * 100:.1f}%")

    for target in thesis['exit_targets']:
        print(f"Target: ${target['price']:,.0f} - {target['reasoning']}")

asyncio.run(generate_thesis())

async def compare_assets():
    """Compare multiple cryptocurrencies for portfolio allocation."""
    mcp_client = MCPClientWrapper()

    assets = ["BTC", "ETH", "SOL"]
    results = {}

    for asset in assets:
        # Generate thesis for each asset
        synthesizer = ThesisSynthesizer(mcp_client=mcp_client)
        thesis = await synthesizer.generate_investment_thesis(asset, horizon_days=30)

        results[asset] = {
            "recommendation": thesis["recommendation"],
            "confidence": thesis["confidence"],
            "risk_score": thesis.get("risk_score", 0),
            "position_size": thesis["position_size"]
        }

    # Sort by confidence and risk-adjusted returns
    ranked = sorted(results.items(), key=lambda x: x[1]["confidence"], reverse=True)

    for asset, metrics in ranked:
        print(f"{asset}: {metrics['recommendation']} (confidence: {metrics['confidence']:.2f})")

asyncio.run(compare_assets())

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Format code
black .

# Lint
ruff check .

# Type check
mypy agents/ mcp_client.py

crypto-skills-mcp/
├── agents/              # Specialized cryptocurrency analysis agents
│   ├── __init__.py
│   ├── crypto_macro_analyst.py      # Macro regime and institutional flows
│   ├── crypto_vc_analyst.py         # Fundamental due diligence
│   ├── crypto_sentiment_analyst.py  # Market psychology and sentiment
│   └── thesis_synthesizer.py        # Investment thesis generation
├── mcp_client.py        # MCP Client Wrapper with caching and retry logic
├── examples/            # Production usage examples
│   └── production_usage.py
├── tests/               # Unit and integration tests
│   ├── __init__.py
│   ├── conftest.py      # Pytest fixtures and configuration
│   ├── test_agents.py   # Agent unit tests
│   └── test_mcp_client.py
├── .github/             # GitHub Actions workflows
│   └── workflows/
│       ├── tests.yml    # CI testing across OS and Python versions
│       ├── lint.yml     # Code quality checks
│       └── release.yml  # Automated PyPI publishing
├── pyproject.toml       # Modern Python package configuration
├── setup.py             # Package setup with modular installation
├── requirements.txt     # Core dependencies
├── LICENSE              # MIT License
├── CONTRIBUTING.md      # Contribution guidelines
├── CHANGELOG.md         # Version history
└── README.md            # This file