Download app/agent_system.py from cryptorugmunch/rugmuncher-backend: direct link, hf CLI and curl.
- Browser
- Download file 25.1 kB
-
https://huggingface.co/cryptorugmunch/rugmuncher-backend/resolve/main/app/agent_system.py
- Command line
-
hf download hf://cryptorugmunch/rugmuncher-backend/app/agent_system.py
-
curl -L -o agent_system.py https://huggingface.co/cryptorugmunch/rugmuncher-backend/resolve/main/app/agent_system.py
25.1 kB
| """ | |
| RMI Agent System β Agent MUNCH Multi-Specialist Intelligence Operative | |
| ====================================================================== | |
| 9 specialized crypto intelligence operatives, each a distinct skill module | |
| under the Agent MUNCH persona. Uses free OpenRouter models with fallbacks. | |
| Architecture: | |
| - Each specialist has its own system prompt, model preference, and output format | |
| - RAG context injection: fetches real DataBus data before LLM call | |
| - Smart caching: checks Redis for previously answered similar questions | |
| - Keyword + explicit skill routing | |
| - SSE streaming for real-time output | |
| Specialists: | |
| rug_detect β Token rug/honeypot detection | |
| wallet_forensics β Wallet funding trail analysis | |
| market_intel β Market conditions & whale analysis | |
| bundle_detect β Coordinated trading detection | |
| code_audit β Smart contract vulnerability scanning | |
| social_sentiment β Sentiment divergence analysis | |
| airdrop_assess β Airdrop claim safety evaluation | |
| defi_yield β DeFi yield trap identification | |
| general β Agent MUNCH default operative | |
| """ | |
| import contextlib | |
| import hashlib | |
| import json | |
| import logging | |
| import os | |
| from collections.abc import AsyncGenerator | |
| from dataclasses import dataclass, field | |
| logger = logging.getLogger("agent.system") | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # AGENT DEFINITIONS | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| class AgentDef: | |
| id: str | |
| name: str | |
| icon: str | |
| description: str | |
| system_prompt: str | |
| model: str | |
| fallbacks: list[str] = field(default_factory=list) | |
| temperature: float = 0.3 | |
| max_tokens: int = 800 | |
| color: str = "#8B5CF6" # UI color | |
| output_format: str = "standard" # standard, evidence_chain, threat_rating | |
| databus_context: list[str] = field(default_factory=list) # DataBus chains to inject | |
| MUNCH_BASE = """You are Agent MUNCH, a crypto intelligence operative for Rug Munch Intelligence. | |
| You are NOT a generic AI assistant. You are a highly trained specialist operative. | |
| Speak like briefing a client β direct, forensic, precise. Never say "I'm an AI" or "as an AI." | |
| Use threat classification: CRITICAL, HIGH, MEDIUM, LOW. Use confidence scores (0-100%). | |
| Reference real data when available. If you lack data, say "I need to pull [X] data β recommend running [tool]." | |
| Never fabricate addresses, prices, or on-chain data. Be skeptical. Trust nothing until verified. | |
| """ | |
| AGENTS = { | |
| "rug_detect": AgentDef( | |
| id="rug_detect", | |
| name="Rug Detection Specialist", | |
| icon="π‘οΈ", | |
| description="Token rug pull, honeypot, and scam detection specialist", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in detecting rug pulls, honeypots, and token scams. | |
| Focus on: liquidity lock verification, mint authority analysis, deployer wallet forensics, | |
| honeypot detection patterns, proxy contract abuse, concentrated ownership risk. | |
| Format output as THREAT RATING: [LEVEL] (Score: X/100) followed by KEY FINDINGS and RECOMMENDATION. | |
| When you identify a rug pattern, say "RUG PATTERN DETECTED" with specific evidence.""", | |
| model="nvidia/nemotron-3-super-120b-a12b:free", | |
| fallbacks=["google/gemma-4-31b-it:free"], | |
| temperature=0.2, | |
| color="#EF4444", | |
| output_format="threat_rating", | |
| databus_context=["alerts", "market_overview"], | |
| ), | |
| "wallet_forensics": AgentDef( | |
| id="wallet_forensics", | |
| name="Wallet Forensic Investigator", | |
| icon="π", | |
| description="Wallet funding trail analysis, entity resolution, insider network mapping", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in wallet forensics and funding trail analysis. | |
| Focus on: wallet clustering, deployer wallet networks, mixer exit detection, | |
| insider wallet identification, counterparty risk, funding source tracing. | |
| Format output as CHAIN OF CUSTODY: wallet β funding source β linked wallets β risk classification. | |
| Classify wallets as: SMART MONEY, INSIDER, MEME DUMPER, MIXER EXIT, TEAM WALLET, MEV BOT.""", | |
| model="google/gemma-4-26b-a4b-it:free", | |
| fallbacks=["nvidia/nemotron-3-super-120b-a12b:free"], | |
| temperature=0.2, | |
| color="#22D3EE", | |
| output_format="evidence_chain", | |
| databus_context=["whale_alerts", "alerts"], | |
| ), | |
| "market_intel": AgentDef( | |
| id="market_intel", | |
| name="Market Intelligence Analyst", | |
| icon="π", | |
| description="Market conditions, whale movements, Fear & Greed, prediction markets", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in market intelligence analysis. | |
| Focus on: whale movement interpretation, DEX flow anomalies, volume spikes, | |
| Fear & Greed contextualization, sentiment divergence from on-chain data, | |
| prediction market signals, macro crypto conditions. | |
| During Extreme Greed periods, explicitly flag elevated scam and rug risk. | |
| Be data-driven β cite specific metrics, not vague observations.""", | |
| model="qwen/qwen3-next-80b-a3b-instruct:free", | |
| fallbacks=["nvidia/nemotron-3-super-120b-a12b:free"], | |
| temperature=0.4, | |
| color="#8B5CF6", | |
| output_format="standard", | |
| databus_context=["market_overview", "trending", "whale_alerts"], | |
| ), | |
| "bundle_detect": AgentDef( | |
| id="bundle_detect", | |
| name="Bundle Detection Operator", | |
| icon="π", | |
| description="Coordinated trading detection, wash trading, same-timestamp analysis", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in detecting coordinated trading bundles. | |
| Focus on: same-timestamp transaction clusters, gas-funded wallet groups, | |
| wash trading patterns, insider pre-positioning, coordinated buy/sell walls, | |
| MEV sandwich attack patterns, token launch sniping detection. | |
| Format: BUNDLE IDENTIFIED β wallets involved β timing β estimated profit β THREAT LEVEL.""", | |
| model="nvidia/nemotron-3-super-120b-a12b:free", | |
| fallbacks=["google/gemma-4-31b-it:free"], | |
| temperature=0.2, | |
| color="#F59E0B", | |
| output_format="evidence_chain", | |
| databus_context=["bundle_detect", "alerts"], | |
| ), | |
| "code_audit": AgentDef( | |
| id="code_audit", | |
| name="Multi-Chain Code Auditor", | |
| icon="π", | |
| description="Smart contract vulnerability scanning across EVM, Solana, and more", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in smart contract code auditing across multiple chains. | |
| EVM focus: proxy upgrade abuse, unrestricted mint, hidden owner functions, reentrancy, unsafe delegatecall. | |
| Solana focus: mint authority freeze, close authority, unchecked CPI, fake CPI returns. | |
| Base focus: unverified contract risks, permissioned token patterns. | |
| Format: VULNERABILITY SCORECARD listing each finding with severity (CRITICAL/HIGH/MEDIUM/LOW), | |
| the specific code pattern, and remediation.""", | |
| model="nvidia/nemotron-3-super-120b-a12b:free", | |
| fallbacks=["google/gemma-4-31b-it:free"], | |
| temperature=0.2, | |
| color="#06D6A0", | |
| output_format="threat_rating", | |
| databus_context=["alerts"], | |
| ), | |
| "social_sentiment": AgentDef( | |
| id="social_sentiment", | |
| name="Social Sentiment Decoder", | |
| icon="π£οΈ", | |
| description="X/Twitter sentiment vs on-chain movement divergence analysis", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in social sentiment analysis and its divergence from on-chain reality. | |
| Focus on: Twitter/X sentiment vs actual wallet behavior, pump-and-dump social patterns, | |
| influencer wallet timing correlation, coordinated shill detection, | |
| sentiment manipulation via bot networks, "this is fine" divergence signals. | |
| Key insight: when sentiment says BUY but whales are EXITING, that's the classic divergence. | |
| Format: SENTIMENT vs ON-CHAIN: divergence score, social signals, on-chain reality, ASSESSMENT.""", | |
| model="qwen/qwen3-next-80b-a3b-instruct:free", | |
| fallbacks=["nvidia/nemotron-3-super-120b-a12b:free"], | |
| temperature=0.4, | |
| color="#38BDF8", | |
| output_format="standard", | |
| databus_context=["market_overview", "trending", "whale_alerts"], | |
| ), | |
| "airdrop_assess": AgentDef( | |
| id="airdrop_assess", | |
| name="Airdrop Threat Assessor", | |
| icon="π", | |
| description="Airdrop claim safety, signature risk, wallet drain potential evaluation", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in airdrop and claim safety assessment. | |
| Focus on: contract verification for claims, signature requirement risks (EIP-712 phishing), | |
| wallet drain potential in claim processes, gas spike exploitation during claims, | |
| fake airdrop phishing detection, legitimate vs scam airdrop differentiation. | |
| Key rule: NEVER recommend clicking a claim link without verifying the contract address on-chain. | |
| Format: AIRDROP RATING with legitimacy score, claim safety checklist, and specific risks.""", | |
| model="google/gemma-4-31b-it:free", | |
| fallbacks=["nvidia/nemotron-3-super-120b-a12b:free"], | |
| temperature=0.3, | |
| color="#A78BFA", | |
| output_format="threat_rating", | |
| databus_context=["alerts", "market_overview"], | |
| ), | |
| "defi_yield": AgentDef( | |
| id="defi_yield", | |
| name="DeFi Yield Trap Detector", | |
| icon="π", | |
| description="Unsustainable yield detection, emission inflation, TVL manipulation", | |
| system_prompt=MUNCH_BASE | |
| + """You specialize in detecting unsustainable DeFi yield mechanisms. | |
| Focus on: emission schedule inflation analysis, TVL manipulation via protocol-owned liquidity, | |
| reward token devaluation trajectories, hidden lock periods and withdrawal gates, | |
| yield farming that requires depositing into unverified contracts, | |
| leveraged yield loops that amplify risk. | |
| Key pattern: if yield >30% APY with no clear revenue source, it's likely a yield trap. | |
| Format: YIELD SAFETY SCORE with sustainability analysis, risk factors, and honest yield estimate.""", | |
| model="qwen/qwen3-next-80b-a3b-instruct:free", | |
| fallbacks=["nvidia/nemotron-3-super-120b-a12b:free"], | |
| temperature=0.3, | |
| color="#FB3B76", | |
| output_format="threat_rating", | |
| databus_context=["market_overview", "trending"], | |
| ), | |
| "general": AgentDef( | |
| id="general", | |
| name="Agent MUNCH", | |
| icon="π΅οΈ", | |
| description="General crypto intelligence operative β your all-purpose specialist", | |
| system_prompt=MUNCH_BASE | |
| + """You are the default operative, skilled in all areas of crypto intelligence. | |
| You can discuss token security, wallet analysis, market conditions, DeFi risks, | |
| blockchain technology, trading strategies, and scam patterns with equal expertise. | |
| When a question falls outside your expertise, say "This requires [specialist name] deployment β | |
| I recommend switching to that skill for deeper analysis." | |
| Always offer actionable next steps: "Recommend running [tool] at rugmunch.io for [specific analysis].""", | |
| model="google/gemma-4-31b-it:free", | |
| fallbacks=["nvidia/nemotron-3-super-120b-a12b:free"], | |
| temperature=0.5, | |
| color="#8B5CF6", | |
| output_format="standard", | |
| databus_context=["market_overview", "alerts"], | |
| ), | |
| } | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # ROUTING | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| ROUTES = { | |
| "rug_detect": [ | |
| "scan", | |
| "token", | |
| "scam", | |
| "rug", | |
| "honeypot", | |
| "contract", | |
| "audit", | |
| "safety", | |
| "risk score", | |
| "verify token", | |
| "check coin", | |
| "rug pull", | |
| "is this safe", | |
| "is this a scam", | |
| ], | |
| "wallet_forensics": [ | |
| "wallet", | |
| "address", | |
| "holder", | |
| "whale", | |
| "smart money", | |
| "portfolio", | |
| "entity", | |
| "counterparty", | |
| "deployer", | |
| "funding", | |
| "trace", | |
| "follow the money", | |
| "cluster", | |
| ], | |
| "market_intel": [ | |
| "market", | |
| "trending", | |
| "fear greed", | |
| "sentiment", | |
| "prediction", | |
| "price", | |
| "volume", | |
| "mover", | |
| "gainer", | |
| "condition", | |
| "macro", | |
| "btc", | |
| "eth", | |
| "sol", | |
| "dominance", | |
| ], | |
| "bundle_detect": [ | |
| "bundle", | |
| "coordinated", | |
| "wash trade", | |
| "same time", | |
| "sniper", | |
| "launch", | |
| "front run", | |
| "sandwich", | |
| "mev", | |
| "bot cluster", | |
| ], | |
| "code_audit": [ | |
| "code", | |
| "contract", | |
| "source", | |
| "audit", | |
| "vulnerability", | |
| "proxy", | |
| "mint authority", | |
| "reentrancy", | |
| "delegatecall", | |
| "verify source", | |
| "solana program", | |
| ], | |
| "social_sentiment": [ | |
| "twitter", | |
| "social", | |
| "sentiment", | |
| "influencer", | |
| "shill", | |
| "hype", | |
| "pump social", | |
| "bot network", | |
| "community sentiment", | |
| "reddit", | |
| ], | |
| "airdrop_assess": [ | |
| "airdrop", | |
| "claim", | |
| "free token", | |
| "signature", | |
| "eip-712", | |
| "phishing claim", | |
| "eligible", | |
| "merkle", | |
| ], | |
| "defi_yield": [ | |
| "yield", | |
| "apy", | |
| "farming", | |
| "liquidity pool", | |
| "staking", | |
| "emission", | |
| "tvl", | |
| "protocol", | |
| "curve", | |
| "convex", | |
| "leveraged", | |
| ], | |
| } | |
| def classify(msg: str) -> str: | |
| m = msg.lower() | |
| for agent_id, keywords in ROUTES.items(): | |
| if any(kw in m for kw in keywords): | |
| return agent_id | |
| return "general" | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # RAG CONTEXT INJECTION | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def fetch_databus_context(chains: list[str]) -> str: | |
| """Fetch real data from DataBus and format as context for the LLM.""" | |
| if not chains: | |
| return "" | |
| context_parts = [] | |
| try: | |
| import httpx | |
| for chain in chains: | |
| try: | |
| url = "http://localhost:8000/api/v1/databus/fetch" | |
| async with httpx.AsyncClient(timeout=8) as c: | |
| r = await c.post(url, json={"data_type": chain, "limit": 5}) | |
| if r.status_code == 200: | |
| data = r.json() | |
| # Extract the actual data payload | |
| result = data.get("data", data.get("results", [{}])) | |
| if isinstance(result, list) and result: | |
| result = result[0].get("data", result[0]) if result else {} | |
| context_parts.append(f"[{chain} DATA]: {json.dumps(result, default=str)[:800]}") | |
| except Exception as e: | |
| logger.warning(f"DataBus context fetch failed for {chain}: {e}") | |
| except Exception as e: | |
| logger.warning(f"DataBus context system unavailable: {e}") | |
| if context_parts: | |
| return "\n\nREAL-TIME PLATFORM DATA (use this in your analysis, do not fabricate):\n" + "\n".join(context_parts) | |
| return "" | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # SMART CACHING | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def check_cache(msg: str, agent_id: str) -> str | None: | |
| """Check Redis for previously answered similar questions.""" | |
| try: | |
| import redis | |
| r = redis.Redis( | |
| host=os.getenv("REDIS_HOST", "localhost"), | |
| port=int(os.getenv("REDIS_PORT", "6379")), | |
| password=os.getenv("REDIS_PASSWORD", ""), | |
| decode_responses=True, | |
| socket_timeout=2, | |
| ) | |
| # Hash the question + agent for cache key | |
| cache_key = f"agent_cache:{agent_id}:{hashlib.sha256(msg.encode()).hexdigest()[:16]}" | |
| cached = r.get(cache_key) | |
| if cached: | |
| logger.info(f"Cache hit for {agent_id}: {cache_key}") | |
| return cached | |
| except Exception: | |
| pass | |
| return None | |
| async def store_cache(msg: str, agent_id: str, response: str, ttl: int = 3600): | |
| """Store response in Redis cache. TTL defaults to 1 hour.""" | |
| try: | |
| import redis | |
| r = redis.Redis( | |
| host=os.getenv("REDIS_HOST", "localhost"), | |
| port=int(os.getenv("REDIS_PORT", "6379")), | |
| password=os.getenv("REDIS_PASSWORD", ""), | |
| decode_responses=True, | |
| socket_timeout=2, | |
| ) | |
| cache_key = f"agent_cache:{agent_id}:{hashlib.sha256(msg.encode()).hexdigest()[:16]}" | |
| # Only cache if response is substantive (>200 chars) | |
| if len(response) > 200: | |
| r.setex(cache_key, ttl, response[:4000]) # Cap stored size | |
| except Exception: | |
| pass | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # STREAMING ROUTER | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def route_and_stream(msg: str, role_hint: str = "") -> AsyncGenerator[dict, None]: | |
| """Route to specialist agent, inject RAG context, stream response. | |
| Provider priority: | |
| 1. Gemini 2.5 Flash (FREE, 1500 RPD, smart, fast) | |
| 2. OpenRouter free models (fallback when Gemini rate-limited) | |
| """ | |
| import httpx | |
| agent_id = role_hint if role_hint in AGENTS else classify(msg) | |
| agent = AGENTS[agent_id] | |
| yield { | |
| "type": "agent", | |
| "role": agent_id, | |
| "name": agent.name, | |
| "icon": agent.icon, | |
| "color": agent.color, | |
| } | |
| # Check cache first -- skip LLM call entirely if we already have the answer | |
| cached = await check_cache(msg, agent_id) | |
| if cached: | |
| yield {"type": "cache_hit", "agent": agent_id} | |
| yield {"type": "token", "text": cached} | |
| yield {"type": "done"} | |
| return | |
| # Fetch RAG context from DataBus | |
| rag_context = await fetch_databus_context(agent.databus_context) | |
| system_with_context = agent.system_prompt + rag_context | |
| messages = [ | |
| {"role": "system", "content": system_with_context}, | |
| {"role": "user", "content": msg}, | |
| ] | |
| full_response = "" | |
| # ββ Provider 1: Gemini (FREE, primary) ββ | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| gemini_keys = [] | |
| for env_var in ["GEMINI_API_KEY", "GEMINI_API_KEY_2", "GEMINI_API_KEY_3"]: | |
| k = os.environ.get(env_var, "") | |
| if k and len(k) > 20: | |
| gemini_keys.append(k) | |
| for gkey in gemini_keys: | |
| try: | |
| # Gemini native streaming API (key in URL, OpenAI-compatible format) | |
| base_url = f"https://generativelanguage.googleapis.com/v1beta/openai/chat/completions?key={gkey}" | |
| headers = {"Content-Type": "application/json"} | |
| body = { | |
| "model": "gemini-2.5-flash", | |
| "messages": messages, | |
| "max_tokens": agent.max_tokens, | |
| "temperature": agent.temperature, | |
| "stream": True, | |
| } | |
| async with httpx.AsyncClient(timeout=45) as c: | |
| async with c.stream("POST", base_url, json=body, headers=headers) as r: | |
| if r.status_code == 200: | |
| async for line in r.aiter_lines(): | |
| if line.startswith("data: "): | |
| d = line[6:] | |
| if d == "[DONE]": | |
| if full_response: | |
| await store_cache(msg, agent_id, full_response) | |
| yield {"type": "done"} | |
| return | |
| try: | |
| ch = json.loads(d) | |
| txt = ch.get("choices", [{}])[0].get("delta", {}).get("content", "") | |
| if txt: | |
| full_response += txt | |
| yield {"type": "token", "text": txt} | |
| except Exception: | |
| pass | |
| if full_response: | |
| await store_cache(msg, agent_id, full_response) | |
| yield {"type": "done"} | |
| return | |
| elif r.status_code == 429: | |
| logger.info("Gemini rate-limited, trying next key/fallback") | |
| continue # Try next key or fallback provider | |
| else: | |
| logger.warning(f"Gemini error {r.status_code}, trying fallback") | |
| continue | |
| except Exception as e: | |
| logger.warning(f"Gemini call failed: {e}") | |
| continue | |
| # ββ Provider 2: OpenRouter (fallback, costs credits) ββ | |
| api_key = os.environ.get("OPENROUTER_API_KEY", "") | |
| if not api_key: | |
| b64 = os.environ.get("LLM_API_KEY_B64", "") | |
| if b64: | |
| import base64 | |
| with contextlib.suppress(BaseException): | |
| api_key = base64.b64decode(b64).decode() | |
| if api_key: | |
| models = [agent.model, *agent.fallbacks] | |
| for model in models: | |
| try: | |
| headers = { | |
| "Authorization": f"Bearer {api_key}", | |
| "Content-Type": "application/json", | |
| "HTTP-Referer": "https://rugmunch.io", | |
| "X-Title": f"RMI {agent.name}", | |
| } | |
| body = { | |
| "model": model, | |
| "messages": messages, | |
| "max_tokens": agent.max_tokens, | |
| "temperature": agent.temperature, | |
| "stream": True, | |
| } | |
| async with httpx.AsyncClient(timeout=60) as c, c.stream( | |
| "POST", | |
| "https://openrouter.ai/api/v1/chat/completions", | |
| json=body, | |
| headers=headers, | |
| ) as r: | |
| if r.status_code == 200: | |
| async for line in r.aiter_lines(): | |
| if line.startswith("data: "): | |
| d = line[6:] | |
| if d == "[DONE]": | |
| if full_response: | |
| await store_cache(msg, agent_id, full_response) | |
| yield {"type": "done"} | |
| return | |
| try: | |
| ch = json.loads(d) | |
| txt = ch.get("choices", [{}])[0].get("delta", {}).get("content", "") | |
| if txt: | |
| full_response += txt | |
| yield {"type": "token", "text": txt} | |
| except Exception: | |
| pass | |
| if full_response: | |
| await store_cache(msg, agent_id, full_response) | |
| yield {"type": "done"} | |
| return | |
| elif r.status_code == 429: | |
| continue | |
| except Exception as e: | |
| logger.warning(f"OpenRouter model {model} failed: {e}") | |
| continue | |
| yield { | |
| "type": "error", | |
| "text": "All providers unavailable (Gemini rate-limited, OpenRouter failed)", | |
| } | |
| yield {"type": "done"} | |
| def agents_list() -> list: | |
| return [ | |
| { | |
| "id": a.id, | |
| "name": a.name, | |
| "icon": a.icon, | |
| "model": a.model, | |
| "description": a.description, | |
| "color": a.color, | |
| "output_format": a.output_format, | |
| } | |
| for a in AGENTS.values() | |
| ] | |