Live Demo: https://shishou.streamlit.app
Shishou is an intelligent hackathon assistant that evaluates project ideas against thousands of past hackathon winners. It uses a multi-modal approach to score projects on Novelty, Technical Complexity, Viability, and Design.
We've all been there: 2 AM at a hackathon, wondering, "Has this been done before?" or "Is this technical enough to win?" Judges are overwhelmed, and feedback is often scarce. We wanted to build Shishou (Japanese for "Sensei" or "Master")—an intelligent mentor that gives you instant, data-driven feedback on your project idea before you write a single line of code.
Shishou is a multi-modal AI judge. You feed it your project name, description, tech stack, and even a mock-up screenshot. It then:
- Checks Novelty: Searches a vector database of thousands of past hackathon winners to see if your idea is unique.
- Audits Tech Stack: uses Llama 3 (via Groq) to evaluate the complexity and viability of your proposed architecture.
- Critiques Design: Uses Llama 4 Scout (via Groq) to "look" at your UI and score it on aesthetics and accessibility.
- Scores You: Generates a unified scorecard with actionable advice.
We built Shishou using a best-in-class AI stack:
- Orchestration: LangChain to manage the flow between different agents.
- Reasoning Engine: Groq powering Llama 3.3 70B for lightning-fast auditing.
- Vision: Groq powering Llama 4 Scout for instant UI feedback.
- Embeddings: HuggingFace (Local) for zero-cost, private RAG.
- Vector Database: FAISS to store and retrieve similar projects from our dataset.
- Frontend: Streamlit, heavily customized with raw CSS to achieve a "Glassmorphism" aesthetic that stands out.
- Model Orchestration: Coordinating between Groq (for speed) and seamless local embeddings required careful error handling.
- Streamlit Limitations: Breaking out of Streamlit's standard look to create a "Next.js-quality" UI required injecting custom CSS and hacking the layout components.
- Latency: We wanted the feedback to be near-instant. Optimizing the RAG retrieval and switching to Groq for the text reasoning significantly cut down our wait times.
- The "Judge's Eye": Successfully implementing a Vision model that can actually give meaningful design feedback on a UI screenshot.
- The Speed: Leveraging Groq to make the text analysis feel instantaneous.
- The Aesthetic: Building a Streamlit app that doesn't look like a Streamlit app.
We learned the immense value of RAG (Retrieval-Augmented Generation) for validation. Letting the AI "see" past winners made its advice much more grounded in reality rather than just generic encouragement. We also learned that Groq's speed is a game-changer for agentic workflows where multiple prompts are chained together.
- Live Pitch Mode: Analyze a video pitch using multimodal capabilities.
- Devpost Sync: Automatically scrape the latest winners to keep the knowledge base current.
- Team Matchmaking:Suggesting teammates based on the missing skills in your tech stack.
- Novelty Scoring (RAG): Retrieves similar past winning projects using FAISS and Local Embeddings to determine how unique your idea is.
- Design Analysis (Vision): Uses Llama 4 Scout to critique UI screenshots for hierarchy, accessibility, and aesthetics.
- Technical Audit (Reasoning): Uses Llama 3 (via Groq) to analyze the tech stack and implementation details, checking for advanced AI components (Agents, RAG, Fine-tuning).
- Modern UI: Built with Streamlit featuring a custom "Organic Glassmorphism" theme inspired by modern design trends.
- Frontend: Streamlit, Plotly
- Backend: Python, LangChain
- AI Models:
- Reasoning: Llama 3.3 70B (Groq)
- Vision: Llama 4 Scout (17B Multimodal via Groq)
- Embeddings:
all-MiniLM-L6-v2(Local HuggingFace) - Free & Unlimited.
- Vector Database: FAISS (Stores 10k+ projects locally)
git clone https://github.com/kkadapa/Shishou.git
cd Shishoupip install -r requirements.txtCreate a .env file in the root directory:
GROQ_API_KEY=your_groq_api_keyBefore running the app, you need to generate the embeddings index for the RAG engine.
python backend/build_index.pyThis may take a few minutes as it processes the hackathon dataset.
streamlit run frontend/app.pyhackalytics/
├── backend/
│ ├── build_index.py # Script to generate FAISS index
│ ├── evaluator.py # Main scoring logic (LLM + Vision)
│ ├── rag_engine.py # RAG logic (Embeddings + Retrieval)
│ └── faiss_index/ # Generated vector store (gitignored)
├── frontend/
│ └── app.py # Streamlit UI
├── data/
│ └── hackathon_data.csv
├── requirements.txt
└── README.md
graph TD
subgraph Frontend
UI[Streamlit Interface] -->|User Input| Inputs{Project Data}
style UI fill:#0A0A0A,stroke:#00F2FF,color:#fff
end
subgraph Backend_Processing
Inputs -->|Description + Stack| Embed["HuggingFace Embeddings\n(all-MiniLM-L6-v2 · Local)"]
Inputs -->|UI Screenshot| Vision["Groq Vision Model\n(Llama 4 Scout 17B)"]
Inputs -->|Text Data| LLM["Groq LLM\n(Llama 3.3 70B)"]
subgraph RAG_System
DB[(Hackathon Dataset)] -->|Pre-computed| Index[FAISS Vector Store]
Embed -->|Query Vector| Index
Index -->|Retrieve Similar| Sims[Top 5 Similar Projects]
Sims -->|Context| NovCalc[Novelty Scorer]
end
subgraph Scoring_Engine
Vision -->|Design Analysis| S_Des[Design Score]
LLM -->|Tech & Viability & AI Sub-scores| S_Gen[General Scores]
NovCalc -->|Uniqueness| S_Nov[Novelty Score]
end
S_Des --> Aggregator[Final Score Aggregator]
S_Gen --> Aggregator
S_Nov --> Aggregator
end
Aggregator -->|JSON Result| UI
style Embed fill:#222,stroke:#7CFF7C,color:#fff
style Vision fill:#222,stroke:#FF00E5,color:#fff
style LLM fill:#222,stroke:#00F2FF,color:#fff
style Index fill:#222,stroke:#00F2FF,color:#fff
MIT