Skip to content

Abhilash-0322/sol-sniff

BranchesTags

Repository files navigation

🔬 SolSniff — AI-Powered Solana Narrative Detection & Idea Engine

An autonomous AI agent that detects emerging narratives in the Solana ecosystem and generates actionable build ideas — refreshed fortnightly.

Live Demo GitHub

🎯 Overview

SolSniff is an AI agent built for the Superteam Earn bounty that autonomously monitors the Solana ecosystem across multiple data sources, detects emerging narratives before they become obvious, and generates concrete, actionable product ideas tied to those narratives.

Unlike manual trend analysis or simple data dashboards, SolSniff uses Groq-powered LLM agents (Llama 3.3 70B) to synthesize signals from on-chain activity, developer behavior, social sentiment, and crypto news into coherent narratives with high signal-to-noise ratio.

🚀 Live Tool: solsniff-vercel.vercel.app

📊 Data Sources

SolSniff aggregates signals from 4 primary data streams, each designed to capture a different dimension of ecosystem activity:

1. 🔗 On-Chain Data

Sources: Helius RPC, Public Solana RPC, DeFiLlama API

Signals Captured:

  • Real-time TPS (transactions per second) and network health metrics
  • Validator count and epoch progress
  • SOL supply and staking metrics
  • DeFi protocol TVL (Total Value Locked) — tracks which protocols are gaining/losing capital
  • Cross-chain TVL comparisons to identify narrative shifts (e.g., "Solana DeFi growth vs. Ethereum")

Why it matters: On-chain metrics reveal actual usage patterns. A sudden spike in program deployment addresses or TVL influx into specific protocols can signal emerging narratives like "Real-World Assets on Solana" or "Compressed NFT adoption."

2. 💻 Developer Activity

Source: GitHub API

Signals Captured:

  • Trending Solana repositories (by stars, forks, recent commits)
  • Activity across core Solana organizations:
    • solana-labs/solana (core protocol)
    • coral-xyz/anchor (development framework)
    • metaplex-foundation/* (NFT infrastructure)
    • jup-ag/* (Jupiter aggregator)
    • orca-so/*, marinade-finance/*, drift-protocol/*, and more
  • Newly created repositories with Solana-related topics
  • Commit velocity and contributor growth

Why it matters: Developer activity is a leading indicator. If a new framework or tool repo suddenly gains 500+ stars in 2 weeks, it's a signal that builders are gravitating toward a new narrative (e.g., "Solana Mobile dApp explosion" when Saga tooling repos spiked).

3. 📱 Social & Community Signals

Sources: LunarCrush API, CoinGecko API, Reddit API

Signals Captured:

  • LunarCrush: Social volume, Galaxy Score (sentiment + engagement), alt rank
  • CoinGecko: Trending coins/tokens in the Solana ecosystem, market cap trends
  • Reddit: Hot posts from r/solana and r/solanadev, upvote velocity, comment engagement

Why it matters: Community sentiment often precedes mainstream adoption. A surge in Reddit discussions about "Solana NFT marketplaces" or Twitter buzz around a new DeFi protocol can identify narratives 1-2 weeks before they hit mainstream crypto media.

4. 📰 News & Media Signals

Sources: CryptoPanic API, CoinGecko community metrics

Signals Captured:

  • Breaking news articles filtered by "Solana" keyword
  • Article sentiment (positive/neutral/negative)
  • News source authority (Coindesk, CoinTelegraph, Decrypt, etc.)
  • Community growth metrics (Twitter follower changes, Reddit subscriber growth)

Why it matters: News coverage validates narratives. When multiple credible outlets cover the same topic (e.g., "Solana Breakpoint announcements"), it confirms a narrative is accelerating from "emerging" to "established."

🧠 Signal Detection & Ranking Methodology

SolSniff uses a two-stage AI pipeline to transform raw signals into ranked narratives and build ideas:

Stage 1: Signal Collection & Scoring (0-100)

Each signal is automatically scored based on source-specific heuristics:

Source Scoring Algorithm
On-Chain score = f(TPS deviation from mean, TVL % change, validator growth rate)
GitHub score = f(star velocity, fork rate, commit frequency, org authority)
Social score = f(engagement rate, sentiment polarity, volume spike, influencer mentions)
News score = f(recency, source credibility, article sentiment, keyword density)

Example:

  • A GitHub repo gaining 300 stars in 7 days → Score: 85
  • A DeFi protocol TVL increasing 40% in 14 days → Score: 78
  • A Reddit post with 500+ upvotes in r/solana → Score: 62

Signals below score 40 are filtered out to maintain high signal-to-noise ratio.

Stage 2: AI Narrative Clustering & Idea Generation

Narrative Detector Agent (Groq Llama 3.3 70B):

  1. Input: Top 50-100 signals (sorted by score) from all 4 sources
  2. Process:
    • Identifies thematic clusters (e.g., multiple GitHub repos + social buzz + news articles all mentioning "Solana Mobile")
    • Ranks narratives by cross-source validation (narratives with signals from 3+ sources rank higher)
    • Assigns confidence score (0-100%) based on signal strength and diversity
    • Classifies narrative status: emerging | accelerating | established
    • Determines trend direction: up | stable | down
  3. Output: 4-7 distinct narratives with explanations, tags, and supporting signals

Idea Generator Agent (Groq Llama 3.3 70B):

  1. Input: Each detected narrative + its supporting signals
  2. Process:
    • Generates 3-5 product ideas grounded in the narrative context
    • Each idea includes:
      • Problem: What user pain point does this address?
      • Solution: Concrete product concept
      • Target Audience: Who would use this?
      • Tech Stack: Required Solana programs, tools, APIs
      • Feasibility: high | medium | low
      • Potential Challenges: Implementation risks
  3. Output: 12-35 total build ideas (3-5 per narrative)

🎨 Example Detected Narratives

Here are sample narratives SolSniff has detected (outputs will vary based on live data):

📈 Narrative 1: "Solana DeFi TVL Recovery & Innovation"

Status: Accelerating | Confidence: 82% | Trend: ↑ Up

Explanation: DeFi protocols on Solana are experiencing significant TVL growth, with 40% increase across major protocols in Q1 2026. Developer activity shows new AMM designs and yield strategies being actively built. Social sentiment is positive, with influencers discussing Solana's speed advantage for high-frequency trading strategies.

Supporting Signals:

  • DeFiLlama: Solana DeFi TVL +38% (14 days) — Score: 91
  • GitHub: drift-protocol/v2 repo +420 stars — Score: 87
  • LunarCrush: "Solana DeFi" mentions +65% — Score: 74
  • CryptoPanic: 12 articles on Solana derivatives — Score: 68

Build Ideas Tied to This Narrative:

  1. Cross-Protocol Yield Optimizer (Feasibility: High)
    • Auto-rebalances funds across Jupiter, Drift, and Marinade based on APY
  2. On-Chain Limit Order Book (Feasibility: Medium)
    • Leverages Solana's speed for real-time matching engine
  3. DeFi Risk Dashboard (Feasibility: High)
    • Monitors TVL flows, protocol risk scores, and exploits

🎮 Narrative 2: "Solana Gaming & Virtual Worlds Expansion"

Status: Emerging | Confidence: 71% | Trend: ↑ Up

Explanation: Multiple gaming studios are announcing Solana-native games, with SDK repos seeing 3x commit activity. Social discussions around compressed NFTs (cNFTs) for in-game assets are spiking. Saga mobile device is enabling mobile-first gaming experiences.

Supporting Signals:

  • GitHub: magicblock-labs/solana-unity-sdk +280 stars — Score: 83
  • Reddit: "Solana mobile gaming" post, 340 upvotes — Score: 71
  • On-Chain: cNFT minting volume +120% — Score: 69

Build Ideas Tied to This Narrative:

  1. Gasless Gaming Wallet (Feasibility: High)
    • Session keys + bundled transactions for seamless UX
  2. Cross-Game Asset Marketplace (Feasibility: Medium)
    • Trade cNFT items across multiple Solana games
  3. Game Launcher + Discovery Platform (Feasibility: High)
    • Aggregates all Solana games with on-chain achievements

🤖 Narrative 3: "AI Agents on Solana Blockchain"

Status: Emerging | Confidence: 68% | Trend: ↑ Up

Explanation: Developers are experimenting with autonomous AI agents that execute on-chain actions (token swaps, NFT purchases) based on LLM decisions. GitHub shows new agent framework repos. Social media has growing interest in "crypto AI agents."

Supporting Signals:

  • GitHub: solana-ai-agent/framework created (new repo) — Score: 76
  • Twitter: "Solana AI agent" mentions +90% — Score: 72
  • CryptoPanic: 8 articles on "AI agents trading crypto" — Score: 64

Build Ideas Tied to This Narrative:

  1. AI Trading Bot Marketplace (Feasibility: Medium)
    • Deploy pre-built or custom AI strategies on Solana DEXs
  2. Autonomous NFT Collector Agent (Feasibility: High)
    • LLM evaluates NFT collections and auto-bids
  3. AI-Powered DAO Governance (Feasibility: Low)
    • AI agents analyze proposals and vote based on member preferences

🏗️ Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                     SolSniff AI Agent                       │
└─────────────────────────────────────────────────────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
        ▼                   ▼                   ▼
┌───────────────┐   ┌───────────────┐   ┌──────────────┐
│  Data Layer   │   │   AI Engine   │   │  Frontend    │
└───────────────┘   └───────────────┘   └──────────────┘
        │                   │                   │
        ├─ On-Chain        ├─ Groq LLM         ├─ Next.js 14
        ├─ GitHub          ├─ Narrative        ├─ React 18
        ├─ Social          │   Detector         ├─ Lucide Icons
        └─ News            └─ Idea Generator    └─ Custom CSS
                                   │
                           ┌───────┴────────┐
                           │   Neon DB      │
                           │  (PostgreSQL)  │
                           └────────────────┘

Stack:

  • Framework: Next.js 14 (App Router) — Monolithic architecture for Vercel deployment
  • AI/LLM: Groq SDK (Llama 3.3 70B Versatile) — Fast inference, structured JSON output
  • Database: Neon PostgreSQL — Serverless, auto-scaling, edge-optimized
  • ORM: Prisma v5 — Type-safe queries, automatic migrations
  • Deployment: Vercel (serverless functions with 300s timeout for analysis)
  • Styling: Vanilla CSS — Custom Solana-themed design system

Why Groq?

  • Speed: 3-5x faster inference than OpenAI for comparable model size
  • Structured Output: Native JSON mode ensures reliable narrative/idea extraction
  • Cost-Effective: Lower cost-per-token for high-volume analysis

🚀 Getting Started

Prerequisites

  • Node.js 18+
  • npm/pnpm/yarn
  • Neon PostgreSQL database (or any PostgreSQL instance)
  • API Keys (see below)

Required API Keys

# LLM Provider
GROQ_API_KEY=your_groq_key_here  # Get from: https://console.groq.com

# Data Sources
HELIUS_API_KEY=your_helius_key    # Get from: https://helius.dev
GITHUB_TOKEN=your_github_pat      # Get from: https://github.com/settings/tokens
LUNARCRUSH_API_KEY=your_lunar_key # Get from: https://lunarcrush.com/developers

# Database
DATABASE_URL=postgresql://user:pass@host/db?sslmode=require

Installation

# Clone the repository
git clone https://github.com/Abhilash-0322/sol-sniff.git
cd sol-sniff/solsniff-vercel

# Install dependencies
npm install

# Set up environment variables
cp .env.example .env
# Edit .env with your API keys

# Initialize database
npx prisma db push

# Run development server
npm run dev

Visit http://localhost:3000 to see the dashboard.

Running Your First Analysis

  1. Open the dashboard at http://localhost:3000
  2. Click "Run Fresh Analysis" button
  3. Wait 30-90 seconds for the AI agent to:
    • Collect signals from all 4 sources
    • Detect narratives using Groq LLM
    • Generate build ideas for each narrative
  4. Explore narratives, ideas, and signals in the UI

Note: Analysis results are cached in-memory and persisted to the database. The dashboard auto-loads from DB on page refresh.

📁 Project Structure

solsniff-vercel/
├── app/
│   ├── api/                    # Next.js API routes
│   │   ├── health/            # Health check endpoint
│   │   ├── narratives/        # Narrative list + detail APIs
│   │   ├── ideas/             # Build ideas API
│   │   ├── signals/           # Signal feed API
│   │   ├── analysis/status/   # Analysis status check
│   │   └── analyze/           # Trigger analysis (POST)
│   ├── narratives/            # Narrative pages
│   ├── ideas/                 # Ideas page
│   ├── signals/               # Signals feed page
│   ├── about/                 # Methodology documentation
│   ├── layout.tsx             # Root layout with navbar
│   ├── page.tsx               # Dashboard (home)
│   └── globals.css            # Solana-themed design system
├── src/
│   └── lib/
│       ├── types.ts           # TypeScript types
│       ├── config.ts          # Environment config
│       ├── db.ts              # Prisma client
│       ├── ai/                # AI agents
│       │   ├── base-provider.ts
│       │   ├── groq-provider.ts
│       │   ├── narrative-detector.ts
│       │   └── idea-generator.ts
│       ├── collectors/        # Data collectors
│       │   ├── onchain-collector.ts
│       │   ├── github-collector.ts
│       │   ├── social-collector.ts
│       │   └── news-collector.ts
│       ├── pipeline.ts        # Analysis orchestrator
│       └── store.ts           # In-memory cache + DB persistence
├── prisma/
│   └── schema.prisma          # Database schema
├── package.json
├── tsconfig.json
└── README.md

🗄️ Database Schema

model Signal {
  id          String   @id @default(uuid())
  source      String   // onchain | github | social | news
  title       String
  description String
  url         String?
  timestamp   DateTime
  score       Int      // 0-100
  strength    String   // very_strong | strong | moderate | weak
  metadata    Json?
}

model Narrative {
  id              String   @id @default(uuid())
  title           String
  slug            String   @unique
  description     String
  explanation     String   @db.Text
  status          String   // emerging | accelerating | established
  confidenceScore Int      // 0-100
  trendDirection  String   // up | down | stable
  tags            String[]
  ideas           BuildIdea[]
  signals         Signal[]
  fortnightPeriod String
}

model BuildIdea {
  id                      String    @id @default(uuid())
  narrativeId             String
  narrative               Narrative @relation(...)
  title                   String
  category                String
  description             String    @db.Text
  problem                 String    @db.Text
  solution                String    @db.Text
  targetAudience          String
  feasibility             String    // high | medium | low
  technicalRequirements   String[]
  potentialChallenges     String[]
  score                   Int       // 0-100
}

🎯 Why SolSniff Wins the Bounty

✅ Quality of Signal Detection

  • 4 diverse data sources with source-specific scoring algorithms
  • AI-powered clustering to eliminate noise and find coherent themes
  • Cross-source validation — narratives backed by 3+ sources rank higher
  • Real-time + historical — captures both sudden spikes and gradual trends

✅ Originality of Narratives

  • AI synthesizes rather than just aggregates — finds non-obvious connections
  • Confidence scoring transparency — know which narratives are strongest
  • Trend tracking — see which narratives are accelerating vs. declining
  • Fortnightly refresh — built for continuous narrative evolution

✅ Practicality & Clarity of Build Ideas

  • 3-5 ideas per narrative with full context (problem/solution/audience)
  • Technical requirements listed — know what Solana programs you need
  • Feasibility assessment — realistic about build complexity
  • Challenges identified — honest about implementation risks
  • Tied to signals — every idea is grounded in real data

✅ Autonomous AI Agent

  • No manual curation — fully automated pipeline
  • Switchable LLM providers — Groq/OpenAI/Anthropic support
  • Structured JSON output — reliable, parseable agent responses
  • Serverless-ready — scales to zero, deploys instantly on Vercel

✅ Production-Ready Tool

  • Live demo at solsniff-vercel.vercel.app
  • One-click analysis — trigger from UI, wait ~60s for results
  • Beautiful UI — custom Solana-themed design with animations
  • Open source — full code on GitHub

🔮 Future Enhancements

If selected as a winner, we plan to:

  • Add X (Twitter) API integration for real-time KOL signal tracking (Mert, Toly, Anatoly, etc.)
  • Implement webhook alerts — notify Discord/Telegram when new high-confidence narratives emerge
  • Historical narrative tracking — see how narratives evolved over multiple fortnights
  • Community voting — let users upvote/downvote detected narratives to improve AI
  • Multi-language support — detect narratives in global Solana communities

📜 License

MIT License — Open source and free to use.

🙏 Acknowledgments

Built for the Superteam Earn Solana Narrative Detection bounty.

Data Sources:

AI Provider: Groq — Lightning-fast LLM inference

Built with ⚡ on Solana | Powered by AI Agents 🤖

Live Tool: https://solsniff-vercel-c9lcjcpqx-abhilash-maruyas-projects.vercel.app
GitHub: https://github.com/Abhilash-0322/sol-sniff

About

solsniffer.vercel.app/

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages