Initial commit: Bio Nexus pipeline engine — BLAST + UniProt + AlphaFold + AI interpretation (Phase 1)

.gitignore

@@ -0,0 +1,32 @@
+# --- Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.env
+venv/
+.venv/
+
+# --- Node ---
+node_modules/
+.next/
+npm-debug.log*
+
+# --- IDE ---
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# --- OS ---
+.DS_Store
+Thumbs.db
+
+# --- Env files (keep .example, ignore actual keys) ---
+.env.local
+.env.production
+backend/.env
+
+# --- Runtime artifacts ---
+dump.rdb
+*.rdb

MASTER_PLAN.md

@@ -0,0 +1,205 @@
+# Bio Nexus Platform — Master Plan v3.0
+
+> A bioinformatics pipeline engine that removes the need for expertise to get expert results.
+> User arrives with a biological question and raw data. Leaves with a complete, interpreted answer — having touched nothing in between.
+>
+> Solo founder · Indian M.Sc. bioinformatics grad · Product-first
+
+---
+
+## 1. What the Product Actually Is
+
+Not a tool aggregator. Not a BLAST wrapper with AI on top.
+
+The current experience:
+
+```
+NCBI → paste sequence → BLAST → confusing output → copy accession → 
+open UniProt → new tab → scroll entry → open AlphaFold → new tab → 
+download PDB → open PyMOL → read 3 papers → give up or ask a senior
+```
+
+Bio Nexus:
+
+```
+Paste sequence → press Run → read one comprehensive page that explains everything
+```
+
+This is a **pipeline engine**. Every tool output flows into a results aggregator that normalizes, cross-references, and passes the complete picture to both the visualization layer and the AI interpretation layer simultaneously. The AI doesn't just see BLAST output — it sees what the sequence is, what homologs exist with statistical confidence, what the function annotation says, and what the structure looks like.
+
+**New bioinformatics tools become new modules. The architecture never changes — only the pipeline library grows.**
+
+---
+
+## 2. Target User
+
+**NOT** IIT computational biology faculty (they already have workflows).
+
+The real users:
+- **M.Sc. bioinformatics student at JMI or central university** — learning but doesn't know the toolchain
+- **PhD student in biochemistry** — suddenly needs to analyze a protein sequence, uncomfortable with CLI
+- **MBBS researcher at AIIMS** — found an interesting variant, doesn't know what to do
+- **M.Sc. biotechnology final-year project student** — needs results, not tool expertise
+
+These people exist in enormous numbers. They have severe unmet need. You can reach them directly because you **are** one of them.
+
+Pricing reflects this reality:
+
+| Tier | Price | Verification | Users |
+|------|-------|--------------|-------|
+| Student | ₹0 | `.edu.in` email | Current students |
+| Individual | ₹299/mo | — | Early-career researchers |
+| Lab | ₹999/mo (3–5 seats) | — | Small research groups |
+| Institution | Custom | — | University-wide license |
+
+The free student tier is not a loss — it's the growth strategy. Students graduate, become postdocs, become faculty, become the people who approve institutional licenses.
+
+---
+
+## 3. Competitive Moat
+
+Galaxy Project: free, open-source, 15 years old, hundreds of tools, trusted by reviewers.
+
+You cannot beat Galaxy on **breadth** or **reputation**.
+
+You beat them on:
+
+1. **AI interpretation** — Galaxy has none. Results come back raw. Bio Nexus explains everything in plain language.
+2. **Zero setup** — Galaxy requires an account, a server, or an institutional deployment. Bio Nexus requires a Google login.
+3. **Plain language output** — designed explicitly for people who aren't bioinformatics experts. This is the real differentiation.
+
+---
+
+## 4. Architecture
+
+```
+User input
+├── Sequence (FASTA)
+├── Gene list
+├── FASTQ files (Phase 3)
+└── Structure (PDB ID)
+       │
+       ▼
+Pipeline selector
+  "What do you have?" → "What do you want to know?" → pipeline chosen
+       │
+       ▼
+Pipeline engine
+  Task DAG · async workers · Redis queue · Supabase Realtime progress
+       │
+       ├── BLAST (EBI REST API: nr, swissprot, pdb)
+       │     E-value · bit score · % identity · coverage
+       │
+       ├── UniProt (REST lookup)
+       │     Function · domains · disease associations · 24h Redis cache
+       │
+       ├── AlphaFold DB (Phase 1)
+       │     3Dmol.js render · in-browser only · no downloads
+       │
+       ├── Phase 2 modules
+       │     MSA · Phylogenetic tree · Pfam domains
+       │     KEGG pathways · Primer3 · DiffDock (via Replicate)
+       │
+       └── Phase 3 modules
+             RNA-seq · Variant calling · ChIP-seq
+       │
+       ▼
+Results aggregator        ◄── THE KEY PIECE YOUR CURRENT CODEBASE MISSES
+  Merges all tool outputs into structured JSON
+  Normalises formats · resolves cross-references (accession→UniProt→PDB)
+  Hands complete picture to AI + visualisation simultaneously
+       │
+       ├── Visualisation layer
+       │     MSA viewer · 3D structure · Phylogenetic tree
+       │     All in-browser · nothing downloads
+       │
+       └── AI interpretation (LiteLLM · streaming)
+             Plain language report · citation links · confidence indicators
+       │
+       ▼
+Unified result page
+  One URL · shareable · exportable (PDF) · explainable to a first-year M.Sc. student
+```
+
+---
+
+## 5. Phase Breakdown
+
+### Phase 1 — Prove the pipeline engine works (Months 1–4)
+
+One workflow. Done better than anyone else has done it. No feature creep.
+
+**Workflow**: Protein sequence → BLAST (EBI) → UniProt annotation → AlphaFold structure → AI report
+
+**Output**: A single result page:
+- Top BLAST hits with E-value and identity clearly explained
+- UniProt entry distilled to what matters (function, disease associations, active sites, organism)
+- AlphaFold structure rendered in-browser with 3Dmol.js — nothing downloads
+- AI section that ties it all together in plain language a first-year M.Sc. student can read and act on
+
+No one offers this. Galaxy makes you build a workflow manually. EMBL-EBI runs each tool separately. Nobody gives a unified interpreted result.
+
+### Phase 2 — Expand the pipeline library (Months 5–10)
+
+New pipelines:
+- **MSA + phylogenetic tree** — paste sequences, get a tree with evolutionary distances explained
+- **Domain & motif analysis** — Pfam, PROSITE — what are the functional regions
+- **Gene ontology + KEGG enrichment** — given a gene list, what processes are enriched
+- **Primer design** — Primer3 integration, conditions included
+- **Molecular docking** — DiffDock via Replicate (GPU inference API, not local)
+
+Pipeline selector UI: "What do you have?" → "What do you want to know?" → pipeline recommended automatically
+
+### Phase 3 — Handle raw sequencing data (Months 11–18)
+
+- FASTQ → QC → trimming → alignment → variant calling → annotation → interpreted report
+- RNA-seq differential expression
+- Larger infrastructure: file storage, longer jobs, more compute
+- Significantly expands user base from coursework students to researchers doing published work
+
+### Phase 4 — Platform + collaboration (Months 19–30)
+
+- Lab workspaces (PI + students share a project)
+- Custom pipeline builder for advanced users
+- Institution licensing
+- API access for programmatic use
+
+---
+
+## 6. What Changes Right Now
+
+| Principle | Action |
+|-----------|--------|
+| Pipeline engine | Build results aggregator that merges BLAST + UniProt + AlphaFold + AI into one output |
+| Unified result page | Replace separate BLAST/UniProt tabs with single pipeline results view |
+| Student-first | `.edu.in` free tier, ₹299 individual, ₹999 lab |
+| Honest AI | Working Groq key installed. Fallback shows visible banner, not fake analysis |
+| Outreach | Target M.Sc./PhD/MBBS students. One question: "Walk me through the last sequence you tried to analyze" |
+| Architecture | Aggregator layer normalises cross-tool output. AI sees the complete picture, not just one tool's output |
+
+---
+
+## 7. Weekly Rhythm
+
+```
+Mon–Thu    Build (pipeline engine, aggregator, one module at a time)
+Fri        2–3 user calls (students, not faculty)
+Sat        Feedback → incorporate → build-in-public post
+Sun        Plan next week — no coding
+```
+
+**Hard rule**: Two weeks without a user call → stop building, make calls.
+
+---
+
+## 8. The Honest Challenges
+
+1. **Working AI key** — Groq is installed and tested. If API calls fail, the user sees a visible yellow banner, not fake analysis.
+2. **Real user conversations** — Before Phase 2, need 10 conversations with students who tried to analyze a sequence. Ask: "What did you open, what went wrong, how long did it take?"
+3. **GPU budgeting** — DiffDock requires a paid inference API (Replicate). Student tier won't include it. Lab tier ($999/mo) covers the cost.
+4. **Galaxy comparison** — Deep answer: Galaxy gives power users flexibility. Bio Nexus gives non-experts answers. The markets barely overlap.
+
+---
+
+*Bio Nexus Platform — Master Plan v3.0*
+*Pipeline engine · Student-first · India-built*

bio-nexus/phase0/OUTREACH.md

@@ -0,0 +1,110 @@
+# Phase 0 — Researcher Validation (30+ Calls)
+
+## Target List
+
+### Priority 1 — M.Sc. Bioinformatics Programs at Central Universities (15 contacts)
+| # | Name | Institution | Program | Contact | Status |
+|---|------|-------------|---------|---------|--------|
+| 1 | | Jamia Millia Islamia | M.Sc. Bioinformatics | Dept office → student group | |
+| 2 | | AMU Aligarh | M.Sc. Bioinformatics | Dept office → student group | |
+| 3 | | JNU New Delhi | M.Sc. Computational Biology | Dept office → student group | |
+| 4 | | University of Hyderabad | M.Sc. Bioinformatics | Dept office → student group | |
+| 5 | | Pondicherry University | M.Sc. Bioinformatics | Dept office → student group | |
+| 6 | | University of Pune | M.Sc. Bioinformatics | Dept office → student group | |
+| 7 | | University of Calcutta | M.Sc. Bioinformatics | Dept office → student group | |
+| 8 | | University of Madras | M.Sc. Bioinformatics | Dept office → student group | |
+| 9 | | Bharathiar University | M.Sc. Bioinformatics | Dept office → student group | |
+| 10 | | Banaras Hindu University | M.Sc. Bioinformatics | Dept office → student group | |
+| 11 | | University of Kerala | M.Sc. Bioinformatics | Dept office → student group | |
+| 12 | | Goa University | M.Sc. Bioinformatics | Dept office → student group | |
+| 13 | | North-Eastern Hill University | M.Sc. Bioinformatics | Dept office → student group | |
+| 14 | | Tezpur University | M.Sc. Bioinformatics | Dept office → student group | |
+| 15 | | University of Jammu | M.Sc. Bioinformatics | Dept office → student group | |
+
+### Priority 2 — PhD Students (Wet-lab, Need Bioinformatics) (10 contacts)
+| # | Name | Institution | Lab/Dept | Contact | Status |
+|---|------|-------------|----------|---------|--------|
+| 16 | | AIIMS Delhi | Biochemistry PhD | Reach through PubMed → contact | |
+| 17 | | AIIMS Delhi | Pharmacology PhD | Reach through PubMed → contact | |
+| 18 | | NCBS Bangalore | PhD student | Reach through student groups | |
+| 19 | | CCMB Hyderabad | PhD student | Reach through student groups | |
+| 20 | | IISc Bangalore | PhD (Biochemistry) | Reach through department | |
+| 21 | | JNU | PhD (Life Sciences) | Reach through department | |
+| 22 | | University of Delhi | PhD (Zoology) | Reach through department | |
+| 23 | | CSIR-IGIB | PhD student | Reach through student groups | |
+| 24 | | IIT Bombay | PhD (Biosciences) | Reach through department | |
+| 25 | | IISER Pune | PhD (Biology) | Reach through department | |
+
+### Priority 3 — MBBS / MD Researchers (5 contacts)
+| # | Name | Institution | Dept | Contact | Status |
+|---|------|-------------|------|---------|--------|
+| 26 | | AIIMS Delhi | Junior Resident | Reach through student groups | |
+| 27 | | AIIMS Delhi | MD Biochemistry | Reach through PubMed → contact | |
+| 28 | | Maulana Azad Medical College | MBBS + research | Reach through college groups | |
+| 29 | | JIPMER Pondicherry | MD / MS student | Reach through college groups | |
+| 30 | | CMC Vellore | MBBS + research elective | Reach through college groups | |
+
+---
+
+## Cold Outreach Template — For Students
+
+**Subject:** 15 min — struggling with BLAST / protein analysis?
+
+Hey [Name],
+
+I'm a fellow M.Sc. bioinformatics student building a tool that makes protein sequence analysis instant — paste a sequence, get a complete interpreted result without touching NCBI, UniProt, or any command line.
+
+I'd love 15 minutes to understand:
+1. What do you do when you need to analyze a protein sequence?
+2. What's the most frustrating step?
+3. Would instant AI-powered results help?
+
+This is purely a research conversation — no sales pitch, no demo. Just trying to build something useful for people like us.
+
+Want to hop on a quick call this week?
+
+Best,
+Samad (you are yourself)
+Bio Nexus
+
+---
+
+## Call Script (15 minutes)
+
+### Opening (1 min)
+- "I'm building a bioinformatics tool and want to make sure I'm solving real problems real students face. Not a sales call — I want your honest frustration."
+
+### The One Question (10 min)
+- **"Walk me through the last time you tried to analyze a biological sequence."**
+
+Follow-ups (only if needed):
+- What tools did you open first?
+- What went wrong or was confusing?
+- How long did it take from start to having an answer?
+- Did you ask someone for help? Who?
+
+### Closing (4 min)
+- "If you could wave a magic wand and fix one thing about that process, what would it be?"
+- "Is there anyone else in your class/lab who has the same problem?"
+- "Want early access to try the prototype?"
+
+### Post-Call
+- Log feedback in TRACKER.md immediately
+- Add to Beta Users list if interested
+- Send a thank-you text within an hour
+
+---
+
+## Beta Signup Incentive
+- Free lifetime Student tier for first 50 beta testers
+- Your name in the "Thanks to" list on launch
+- Direct line to the founder (me) for feature requests
+
+---
+
+## Success Metrics
+- [ ] 30+ calls completed
+- [ ] 10+ beta signups
+- [ ] 5+ concrete stories of "Here's what I did last week and it was painful"
+- [ ] 3+ student groups / WhatsApp groups joined for outreach
+- [ ] 1+ referral to another student

bio-nexus/phase0/TRACKER.md

@@ -0,0 +1,97 @@
+# Phase 0 — Student Validation Tracker
+
+## Status Legend
+- [ ] Not contacted
+- [~] Message sent, awaiting response
+- [x] Call completed
+- [!] Interested / Beta signup
+- [-] Not interested / No response
+
+---
+
+## Priority 1: M.Sc. Bioinformatics Programs (Central Universities)
+
+| # | Institution | Program | Contact | Status | Notes |
+|---|-------------|---------|---------|--------|-------|
+| 1 | Jamia Millia Islamia | M.Sc. Bioinformatics | Find student group WhatsApp/Telegram | [ ] | Your own program — easiest entry |
+| 2 | AMU Aligarh | M.Sc. Bioinformatics | Reach via departmental mail | [ ] | |
+| 3 | JNU New Delhi | M.Sc. Computational Biology | Find student group | [ ] | |
+| 4 | University of Hyderabad | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 5 | Pondicherry University | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 6 | University of Pune | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 7 | University of Calcutta | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 8 | University of Madras | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 9 | Bharathiar University | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 10 | Banaras Hindu University | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 11 | University of Kerala | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 12 | Goa University | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 13 | NEHU Shillong | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 14 | Tezpur University | M.Sc. Bioinformatics | Find student group | [ ] | |
+| 15 | University of Jammu | M.Sc. Bioinformatics | Find student group | [ ] | |
+
+## Priority 2: PhD Students (Wet-lab needing bioinformatics)
+
+| # | Name | Institution | Lab/Dept | Status | Notes |
+|---|------|-------------|----------|--------|-------|
+| 16 | | AIIMS Delhi | Biochemistry PhD | [ ] | Reach via PubMed → email |
+| 17 | | AIIMS Delhi | Pharmacology PhD | [ ] | Reach via PubMed → email |
+| 18 | | NCBS Bangalore | PhD student | [ ] | Reach via student groups |
+| 19 | | CCMB Hyderabad | PhD student | [ ] | Reach via student groups |
+| 20 | | IISc Bangalore | PhD (Biochemistry) | [ ] | Reach via department |
+| 21 | | JNU | PhD (Life Sciences) | [ ] | Reach via department |
+| 22 | | University of Delhi | PhD (Zoology) | [ ] | Reach via department |
+| 23 | | CSIR-IGIB | PhD student | [ ] | Reach via student groups |
+| 24 | | IIT Bombay | PhD (Biosciences) | [ ] | Reach via department |
+| 25 | | IISER Pune | PhD (Biology) | [ ] | Reach via department |
+
+## Priority 3: MBBS / MD Researchers
+
+| # | Name | Institution | Status | Notes |
+|---|------|-------------|--------|-------|
+| 26 | | AIIMS Delhi — Junior Resident | [ ] | Reach via student groups |
+| 27 | | AIIMS Delhi — MD Biochemistry | [ ] | Reach via PubMed → email |
+| 28 | | Maulana Azad Medical College | [ ] | Reach via college groups |
+| 29 | | JIPMER Pondicherry | [ ] | Reach via college groups |
+| 30 | | CMC Vellore | [ ] | Reach via college groups |
+
+---
+
+## Weekly Targets
+
+### Week 1: 10 calls
+- [ ] 5 from JMI M.Sc. Bioinformatics (your own classmates/batchmates)
+- [ ] 3 from other central university M.Sc. programs
+- [ ] 2 PhD students via cold email
+
+### Week 2: 10 calls
+- [ ] 5 from central universities (new batch)
+- [ ] 3 PhD students
+- [ ] 2 MBBS/MD students
+
+### Week 3: 10 calls
+- [ ] Fill remaining slots from any category
+
+---
+
+## Outreach Log
+
+### Week 1
+| Date | Contact | Institution | Method | Response | Follow-up |
+|------|---------|-------------|--------|----------|-----------|
+| | | | | | |
+
+---
+
+## Feedback Summary
+
+| Theme | Count | Quotes / Notes |
+|-------|-------|----------------|
+| | | |
+
+---
+
+## Beta Signups
+
+| Name | Institution | Program | Email | Date |
+|------|-------------|---------|-------|------|
+| | | | | |

bioai-platform/backend/.env.example

@@ -0,0 +1,4 @@
+GROQ_API_KEY=
+REDIS_URL=redis://localhost:6379
+SUPABASE_URL=
+SUPABASE_SERVICE_ROLE_KEY=

bioai-platform/backend/app/ai/interpreter.py

@@ -0,0 +1,45 @@
+import json
+import os
+from typing import AsyncGenerator
+from litellm import acompletion
+from app.config import settings
+from app.ai.llm_client import llm_client
+from app.ai.prompts import get_prompt
+
+
+async def interpret_stream(pipeline_type: str, context: dict) -> AsyncGenerator[str, None]:
+    if not llm_client.has_api_key():
+        yield _error_event("GROQ_API_KEY is not configured. AI interpretation unavailable.")
+        return
+
+    prompt = llm_client.build_prompt(pipeline_type, context)
+    model = llm_client.model
+
+    try:
+        response = await acompletion(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3,
+            max_tokens=2000,
+            stream=True,
+            api_key=llm_client.api_key,
+        )
+        async for chunk in response:
+            if chunk.choices and chunk.choices[0].delta.content:
+                yield _chunk_event(chunk.choices[0].delta.content)
+
+        yield _done_event({"model": model, "pipeline_type": pipeline_type})
+    except Exception as e:
+        yield _error_event(str(e))
+
+
+def _chunk_event(text: str) -> str:
+    return f"data: {json.dumps({'chunk': text})}\n\n"
+
+
+def _done_event(meta: dict) -> str:
+    return f"data: {json.dumps({'done': True, 'meta': meta})}\n\n"
+
+
+def _error_event(msg: str) -> str:
+    return f"data: {json.dumps({'error': msg})}\n\n"

bioai-platform/backend/app/ai/llm_client.py

@@ -0,0 +1,44 @@
+import os
+from app.config import settings
+from app.ai.prompts import get_prompt
+
+
+class LLMClient:
+    def __init__(self):
+        self.api_key = settings.GROQ_API_KEY
+        self.model = settings.DEFAULT_MODEL
+        self.pro_model = settings.PRO_MODEL
+
+    def has_api_key(self) -> bool:
+        return bool(self.api_key)
+
+    def build_prompt(self, pipeline_type: str, context: dict) -> str:
+        template = get_prompt(pipeline_type)
+        blast = context.get("blast", {})
+        top = blast.get("top_hit", {})
+        uniprot = context.get("uniprot", {}) or {}
+        af = context.get("alphafold", {}) or {}
+
+        return template.format(
+            blast_count=blast.get("count", 0),
+            top_hit_accession=top.get("accession", "N/A"),
+            top_hit_description=top.get("description", "N/A"),
+            top_hit_evalue=top.get("evalue", "N/A"),
+            top_hit_identity_pct=top.get("identity_pct", "N/A"),
+            top_hit_bit_score=top.get("bit_score", "N/A"),
+            uniprot_name=uniprot.get("full_name", "N/A"),
+            uniprot_organism=uniprot.get("organism", "N/A"),
+            uniprot_genes=", ".join(uniprot.get("gene_names", []) or []) or "N/A",
+            uniprot_functions="; ".join(uniprot.get("functions", []) or []) or "N/A",
+            uniprot_locations="; ".join(uniprot.get("subcellular_locations", []) or []) or "N/A",
+            uniprot_keywords=", ".join(uniprot.get("keywords", []) or []) or "N/A",
+            uniprot_go_terms=", ".join(uniprot.get("go_terms", []) or []) or "N/A",
+            uniprot_features="; ".join(
+                f"{f.get('type', '')}: {f.get('description', '')}" for f in (uniprot.get("features", []) or [])
+            ) or "N/A",
+            alphafold_available="Yes" if af.get("structure_available") else "No",
+            alphafold_confidence=af.get("confidence", "N/A"),
+        )
+
+
+llm_client = LLMClient()

bioai-platform/backend/app/ai/prompts.py

@@ -0,0 +1,46 @@
+PROTEIN_ANALYSIS_PROMPT = """You are a computational biology assistant at Bio Nexus. A researcher submitted a protein sequence, and the system ran BLAST, UniProt lookup, and AlphaFold structure retrieval. Here is the complete assembled context.
+
+## BLAST Results
+- Total hits found: {blast_count}
+- Top hit: {top_hit_description} (accession {top_hit_accession})
+- E-value: {top_hit_evalue}
+- Sequence identity: {top_hit_identity_pct}%
+- Bit score: {top_hit_bit_score}
+
+## UniProt Annotations (Top Hit)
+- Protein name: {uniprot_name}
+- Organism: {uniprot_organism}
+- Gene: {uniprot_genes}
+- Function: {uniprot_functions}
+- Subcellular location: {uniprot_locations}
+- Keywords: {uniprot_keywords}
+- GO terms: {uniprot_go_terms}
+- Active sites / binding regions: {uniprot_features}
+
+## AlphaFold Structure
+- Structure available: {alphafold_available}
+- Confidence score (pLDDT): {alphafold_confidence}
+
+## Instructions for your response
+1. Explain what the query protein likely is based on the BLAST hits and UniProt annotations.
+2. Interpret the E-value and identity percentage — what they mean for confidence in the match.
+3. Summarize the protein's function, cellular location, and any known domains or active sites.
+4. If an AlphaFold structure is available, note its confidence and what that means.
+5. Give a concise bottom-line assessment: what the researcher should conclude from this analysis.
+6. Use plain language. Avoid unnecessary jargon. When you use technical terms, explain them briefly.
+
+Write in a helpful, instructive tone. If any data is missing, state that honestly."""
+
+
+FALLBACK_PROMPT = """You are a computational biology assistant. The following BLAST search results were returned, but detailed annotations are not available. Summarize the search results and help the user understand what the top hits mean.
+
+BLAST search found {blast_count} hits.
+Top hit: {top_hit_description} (E-value: {top_hit_evalue}, Identity: {top_hit_identity_pct}%)
+"""
+
+
+def get_prompt(pipeline_type: str) -> str:
+    prompts = {
+        "protein_analysis": PROTEIN_ANALYSIS_PROMPT,
+    }
+    return prompts.get(pipeline_type, FALLBACK_PROMPT)

bioai-platform/backend/app/config.py

@@ -0,0 +1,22 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Settings:
+    GROQ_API_KEY: str = os.getenv("GROQ_API_KEY", "")
+    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379")
+    SUPABASE_URL: str = os.getenv("SUPABASE_URL", "")
+    SUPABASE_SERVICE_ROLE_KEY: str = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+    CELERY_BROKER_URL: str = os.getenv("CELERY_BROKER_URL", "redis://localhost:6379/1")
+    CELERY_RESULT_BACKEND: str = os.getenv("CELERY_RESULT_BACKEND", "redis://localhost:6379/2")
+    EBI_BASE_URL: str = "https://www.ebi.ac.uk/Tools/services/rest/ncbiblast"
+    UNIPROT_BASE_URL: str = "https://rest.uniprot.org/uniprotkb"
+    ALPHAFOLD_DB_URL: str = "https://alphafold.ebi.ac.uk/api/prediction"
+    DAILY_LIMIT: int = 10
+    DEFAULT_MODEL: str = os.getenv("DEFAULT_MODEL", "groq/llama-3.3-70b-versatile")
+    PRO_MODEL: str = os.getenv("PRO_MODEL", "claude-sonnet-4-20250514")
+
+
+settings = Settings()

bioai-platform/backend/app/main.py

@@ -0,0 +1,54 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+from app.routers import pipelines, results, ai, jobs, export, share, waitlist, profile
+from app.services.cache import init_redis
+from app.tools.registration import register_all_tools
+
+limiter = Limiter(key_func=get_remote_address, default_limits=["30/minute"])
+
+app = FastAPI(title="Bio Nexus API", version="0.1.0")
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3001"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(pipelines.router, prefix="/api/pipelines", tags=["pipelines"])
+app.include_router(results.router, prefix="/api/results", tags=["results"])
+app.include_router(ai.router, prefix="/api/ai", tags=["ai"])
+app.include_router(jobs.router, prefix="/api/jobs", tags=["jobs"])
+app.include_router(export.router, prefix="/api/export", tags=["export"])
+app.include_router(share.router, prefix="/api/share", tags=["share"])
+app.include_router(waitlist.router, prefix="/api/waitlist", tags=["waitlist"])
+app.include_router(profile.router, prefix="/api/profile", tags=["profile"])
+
+
+@app.on_event("startup")
+async def startup():
+    init_redis()
+    register_all_tools()
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content={"detail": "Internal server error"},
+    )

bioai-platform/backend/app/pipeline/assembler.py

@@ -0,0 +1,68 @@
+from typing import Any
+
+
+class ContextAssembler:
+    def assemble(
+        self,
+        sequence: str,
+        blast_result: dict,
+        uniprot_result: dict | None,
+        alphafold_result: dict | None,
+    ) -> dict:
+        context = {
+            "query": {
+                "sequence": sequence,
+                "length": len([c for c in sequence if c.isalpha()]),
+            },
+            "blast": self._summarize_blast(blast_result),
+            "uniprot": self._summarize_uniprot(uniprot_result) if uniprot_result else None,
+            "alphafold": alphafold_result,
+        }
+        return context
+
+    def _summarize_blast(self, blast_result: dict) -> dict:
+        hits = blast_result.get("hits", [])
+        summary = {
+            "count": len(hits),
+            "source": blast_result.get("source", "EBI BLAST"),
+            "database": blast_result.get("database", "swissprot"),
+        }
+        if hits:
+            best = hits[0]
+            summary["top_hit"] = {
+                "accession": best.get("accession", ""),
+                "description": best.get("description", ""),
+                "evalue": best.get("evalue", 0),
+                "identity_pct": best.get("identity_pct", 0),
+                "bit_score": best.get("bit_score", 0),
+                "alignment_length": best.get("alignment_length", 0),
+            }
+            summary["hits"] = [
+                {
+                    "accession": h.get("accession", ""),
+                    "description": h.get("description", ""),
+                    "evalue": h.get("evalue", 0),
+                    "identity_pct": h.get("identity_pct", 0),
+                    "bit_score": h.get("bit_score", 0),
+                }
+                for h in hits[:10]
+            ]
+        return summary
+
+    def _summarize_uniprot(self, uniprot_result: dict) -> dict:
+        return {
+            "accession": uniprot_result.get("accession", ""),
+            "full_name": uniprot_result.get("full_name", ""),
+            "organism": uniprot_result.get("organism", ""),
+            "gene_names": uniprot_result.get("gene_names", []),
+            "functions": uniprot_result.get("functions", []),
+            "keywords": uniprot_result.get("keywords", []),
+            "subcellular_locations": uniprot_result.get("subcellular_locations", []),
+            "pdb_ids": uniprot_result.get("pdb_ids", []),
+            "features": [
+                f for f in (uniprot_result.get("features", []) or [])
+                if f.get("type") in ("ACTIVE_SITE", "BINDING", "MUTAGENESIS")
+            ],
+            "go_terms": uniprot_result.get("go_terms", []),
+            "sequence_length": uniprot_result.get("sequence_length", 0),
+        }

bioai-platform/backend/app/pipeline/definitions/protein_analysis.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+PIPELINE_DEFINITION = {
+    "id": "protein_analysis",
+    "name": "Protein Sequence Analysis",
+    "description": "Analyze a protein sequence: BLAST against Swiss-Prot, fetch UniProt annotations, retrieve AlphaFold structure",
+    "input_type": "sequence",
+    "input_label": "Protein sequence (FASTA or plain)",
+    "steps": ["blast", "uniprot", "alphafold"],
+    "default_database": "uniprotkb_swissprot",
+    "default_max_hits": 10,
+}
+
+
+def get_pipeline_definition() -> dict:
+    return PIPELINE_DEFINITION

bioai-platform/backend/app/pipeline/engine.py

@@ -0,0 +1,46 @@
+from typing import Any
+from app.pipeline.registry import registry
+from app.pipeline.assembler import ContextAssembler
+from app.tools.blast import BlastTool
+from app.tools.uniprot import UniprotTool
+from app.tools.alphafold import AlphaFoldTool
+
+
+class PipelineEngine:
+    def __init__(self):
+        self.assembler = ContextAssembler()
+        self.blast_tool = BlastTool()
+        self.uniprot_tool = UniprotTool()
+        self.alphafold_tool = AlphaFoldTool()
+
+    async def execute(self, sequence: str, database: str = "uniprotkb_swissprot", max_hits: int = 10) -> dict:
+        blast_result = await self.blast_tool.run({
+            "sequence": sequence,
+            "database": database,
+            "max_hits": max_hits,
+        })
+
+        if "error" in blast_result:
+            return {"error": blast_result["error"], "steps_completed": []}
+
+        top_accession = ""
+        if blast_result.get("hits"):
+            top_accession = blast_result["hits"][0].get("accession", "")
+
+        uniprot_result = None
+        if top_accession:
+            uniprot_result = await self.uniprot_tool.run({"accession": top_accession})
+
+        alphafold_result = None
+        if top_accession and uniprot_result and "error" not in uniprot_result:
+            alphafold_result = await self.alphafold_tool.run({"uniprot_accession": top_accession})
+
+        context = self.assembler.assemble(sequence, blast_result, uniprot_result, alphafold_result)
+
+        return {
+            "context": context,
+            "steps_completed": ["blast", "uniprot", "alphafold"],
+            "blast_raw": blast_result,
+            "uniprot_raw": uniprot_result,
+            "alphafold_raw": alphafold_result,
+        }

bioai-platform/backend/app/pipeline/registry.py

@@ -0,0 +1,19 @@
+from typing import Any
+from app.tools.base import BaseTool
+
+
+class ToolRegistry:
+    def __init__(self):
+        self._tools: dict[str, BaseTool] = {}
+
+    def register(self, tool: BaseTool):
+        self._tools[tool.name] = tool
+
+    def get(self, name: str) -> BaseTool | None:
+        return self._tools.get(name)
+
+    def list(self) -> list[str]:
+        return list(self._tools.keys())
+
+
+registry = ToolRegistry()

bioai-platform/backend/app/routers/ai.py

@@ -0,0 +1,32 @@
+import json
+import os
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from app.ai.interpreter import interpret_stream
+from app.ai.llm_client import llm_client
+from app.services.rate_limit import check_daily_limit
+
+router = APIRouter()
+
+
+class InterpretRequest(BaseModel):
+    pipeline_type: str = "protein_analysis"
+    context: dict = {}
+
+
+@router.post("/interpret", dependencies=[Depends(check_daily_limit)])
+async def interpret_full_context(req: InterpretRequest):
+    if not llm_client.has_api_key():
+        raise HTTPException(status_code=502, detail="GROQ_API_KEY is not configured")
+
+    prompt = llm_client.build_prompt(req.pipeline_type, req.context)
+    return {"prompt": prompt, "context_size": len(json.dumps(req.context))}
+
+
+@router.post("/interpret/stream", dependencies=[Depends(check_daily_limit)])
+async def interpret_stream_endpoint(req: InterpretRequest):
+    return StreamingResponse(
+        interpret_stream(req.pipeline_type, req.context),
+        media_type="text/event-stream",
+    )

bioai-platform/backend/app/routers/export.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import Response
+from pydantic import BaseModel
+from app.services.export import export_blast_pdf, export_uniprot_pdf
+
+router = APIRouter()
+
+
+class BlastExportRequest(BaseModel):
+    result: dict
+    sequence: str = ""
+
+
+class UniprotExportRequest(BaseModel):
+    data: dict
+
+
+@router.post("/blast")
+async def export_blast(req: BlastExportRequest):
+    try:
+        pdf = export_blast_pdf(req.result, req.sequence)
+        return Response(content=pdf, media_type="application/pdf", headers={
+            "Content-Disposition": "attachment; filename=blast_results.pdf"
+        })
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/uniprot")
+async def export_uniprot(req: UniprotExportRequest):
+    try:
+        pdf = export_uniprot_pdf(req.data)
+        return Response(content=pdf, media_type="application/pdf", headers={
+            "Content-Disposition": f"attachment; filename=uniprot_{req.data.get('accession', 'protein')}.pdf"
+        })
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/pipeline/{job_id}")
+async def export_pipeline(job_id: str):
+    raise HTTPException(status_code=501, detail="Pipeline PDF export coming in Phase 1.5")

bioai-platform/backend/app/routers/jobs.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from datetime import datetime, timezone
+from app.services.supabase import get_supabase
+
+router = APIRouter()
+
+
+@router.get("/count")
+async def job_count(user_id: str = ""):
+    supabase = get_supabase()
+    today = datetime.now(timezone.utc).date().isoformat()
+    result = supabase.table("jobs").select("id", count="exact").gte("created_at", today).execute()
+    count = result.count or 0
+    return {"count": count, "limit": 10, "remaining": max(0, 10 - count)}
+
+
+@router.get("")
+async def list_jobs(user_id: str = ""):
+    supabase = get_supabase()
+    result = supabase.table("jobs").select("*").order("created_at", desc=True).limit(50).execute()
+    return {"jobs": result.data or []}
+
+
+@router.get("/{job_id}")
+async def get_job(job_id: str):
+    supabase = get_supabase()
+    result = supabase.table("jobs").select("*").eq("id", job_id).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return result.data[0]
+
+
+@router.delete("/{job_id}")
+async def delete_job(job_id: str):
+    supabase = get_supabase()
+    supabase.table("jobs").delete().eq("id", job_id).execute()
+    return {"status": "deleted"}

bioai-platform/backend/app/routers/pipelines.py

@@ -0,0 +1,65 @@
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from app.services.validators import validate_fasta, ValidationResult
+from app.pipeline.engine import PipelineEngine
+from app.pipeline.definitions.protein_analysis import get_pipeline_definition
+from app.services.supabase import get_supabase
+from app.services.rate_limit import check_daily_limit
+from app.workers.celery_app import celery_app
+from app.workers.pipeline_worker import run_pipeline_sync
+from datetime import datetime, timezone
+import uuid
+
+router = APIRouter()
+
+
+class PipelineRunRequest(BaseModel):
+    sequence: str
+    pipeline_type: str = "protein_analysis"
+    database: str = "uniprotkb_swissprot"
+    max_hits: int = 10
+
+
+@router.post("/run", dependencies=[Depends(check_daily_limit)])
+async def run_pipeline(req: PipelineRunRequest):
+    validation = validate_fasta(req.sequence, "blast")
+    if not validation.valid:
+        raise HTTPException(status_code=400, detail=validation.error)
+
+    seq = str(validation.sequences[0].seq).upper().replace(" ", "")
+
+    job_id = str(uuid.uuid4())
+    supabase = get_supabase()
+
+    supabase.table("jobs").insert({
+        "id": job_id,
+        "tool": "pipeline",
+        "query_preview": seq[:100],
+        "status": "pending",
+        "pipeline_type": req.pipeline_type,
+        "steps_completed": [],
+        "context_json": None,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    }).execute()
+
+    if celery_app is not None:
+        from app.workers.pipeline_worker import run_pipeline_job
+        run_pipeline_job.delay(job_id, seq, req.database, req.max_hits)
+    else:
+        import threading
+        t = threading.Thread(target=run_pipeline_sync, args=(job_id, seq, req.database, req.max_hits), daemon=True)
+        t.start()
+
+    return {"job_id": job_id, "status": "pending"}
+
+
+@router.get("/definitions")
+async def list_pipeline_definitions():
+    return {"pipelines": [get_pipeline_definition()]}
+
+
+@router.get("/{pipeline_type}/definition")
+async def get_pipeline_definition_endpoint(pipeline_type: str):
+    if pipeline_type == "protein_analysis":
+        return get_pipeline_definition()
+    raise HTTPException(status_code=404, detail=f"Unknown pipeline: {pipeline_type}")

bioai-platform/backend/app/routers/profile.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from app.services.supabase import get_supabase
+
+router = APIRouter()
+
+class ProfileUpdate(BaseModel):
+    full_name: str = ""
+    institution: str = ""
+
+@router.get("")
+async def get_profile(user_id: str = ""):
+    supabase = get_supabase()
+    result = supabase.table("profiles").select("*").limit(1).execute()
+    if result.data:
+        return result.data[0]
+    return {"error": "Profile not found"}
+
+@router.put("")
+async def update_profile(profile: ProfileUpdate, user_id: str = ""):
+    supabase = get_supabase()
+    data = {}
+    if profile.full_name: data["full_name"] = profile.full_name
+    if profile.institution: data["institution"] = profile.institution
+    if data:
+        result = supabase.table("profiles").update(data).eq("id", user_id).execute()
+        return {"status": "updated", "data": result.data[0] if result.data else data}
+    return {"status": "no changes"}

bioai-platform/backend/app/routers/results.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter, HTTPException, Depends
+from app.services.supabase import get_supabase
+from app.ai.interpreter import interpret_stream
+from fastapi.responses import StreamingResponse
+
+router = APIRouter()
+
+
+@router.get("/{job_id}")
+async def get_result(job_id: str):
+    supabase = get_supabase()
+    result = supabase.table("jobs").select("*").eq("id", job_id).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return result.data[0]
+
+
+@router.get("/{job_id}/stream")
+async def stream_result(job_id: str):
+    supabase = get_supabase()
+    job = supabase.table("jobs").select("*").eq("id", job_id).execute()
+    if not job.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    job_data = job.data[0]
+    context = job_data.get("context_json")
+    pipeline_type = job_data.get("pipeline_type", "protein_analysis")
+
+    if not context:
+        raise HTTPException(status_code=400, detail="Job has not completed yet")
+
+    return StreamingResponse(
+        interpret_stream(pipeline_type, context),
+        media_type="text/event-stream",
+    )

bioai-platform/backend/app/routers/share.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter, HTTPException
+from app.services.supabase import get_supabase
+
+router = APIRouter()
+
+
+@router.get("/{token}")
+async def get_shared_result(token: str):
+    supabase = get_supabase()
+    result = supabase.table("jobs").select("*").eq("share_token", token).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Shared result not found")
+    return result.data[0]

bioai-platform/backend/app/routers/waitlist.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import httpx
+from app.config import settings
+
+router = APIRouter()
+
+
+class WaitlistEntry(BaseModel):
+    email: str
+
+
+@router.post("")
+async def join_waitlist(entry: WaitlistEntry):
+    url = f"{settings.SUPABASE_URL}/rest/v1/waitlist"
+    headers = {
+        "apikey": settings.SUPABASE_SERVICE_ROLE_KEY,
+        "Authorization": f"Bearer {settings.SUPABASE_SERVICE_ROLE_KEY}",
+        "Content-Type": "application/json",
+        "Prefer": "return=minimal",
+    }
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(url, headers=headers, json={"email": entry.email})
+        if resp.status_code == 409:
+            raise HTTPException(status_code=409, detail="Already on waitlist")
+        if resp.status_code >= 400:
+            raise HTTPException(status_code=500, detail=resp.text)
+        return {"status": "added", "email": entry.email}

bioai-platform/backend/app/services/cache.py

@@ -0,0 +1,61 @@
+import redis
+import hashlib
+import json
+import functools
+from typing import Callable, Any
+from app.config import settings
+
+_redis = None
+
+
+def init_redis():
+    global _redis
+    try:
+        _redis = redis.from_url(settings.REDIS_URL, decode_responses=True)
+        _redis.ping()
+    except Exception:
+        _redis = None
+
+
+def get_redis():
+    return _redis
+
+
+def cache_get(key: str) -> str | None:
+    r = get_redis()
+    if r:
+        return r.get(key)
+    return None
+
+
+def cache_set(key: str, value: str, ttl: int = 86400):
+    r = get_redis()
+    if r:
+        r.setex(key, ttl, value)
+
+
+def ttl_cache(ttl: int = 86400, prefix: str = "cache"):
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def wrapper(self, input: dict, *args, **kwargs):
+            raw = json.dumps(input, sort_keys=True)
+            key_hash = hashlib.sha256(raw.encode()).hexdigest()[:16]
+            cache_key = f"{prefix}:{key_hash}"
+
+            cached = cache_get(cache_key)
+            if cached is not None:
+                try:
+                    return json.loads(cached)
+                except (json.JSONDecodeError, TypeError):
+                    pass
+
+            result = await func(self, input, *args, **kwargs)
+            try:
+                cache_set(cache_key, json.dumps(result), ttl=ttl)
+            except (TypeError, ValueError):
+                pass
+            return result
+
+        return wrapper
+
+    return decorator

bioai-platform/backend/app/services/export.py

@@ -0,0 +1,130 @@
+from io import BytesIO
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.lib import colors
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+
+def export_blast_pdf(result: dict, sequence: str = "") -> bytes:
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4, topMargin=0.75 * inch, bottomMargin=0.75 * inch)
+    styles = getSampleStyleSheet()
+    elements = []
+
+    title_style = ParagraphStyle("Title2", parent=styles["Title"], fontSize=16, spaceAfter=12)
+    heading_style = ParagraphStyle("Heading", parent=styles["Heading2"], fontSize=12, spaceAfter=6, textColor=colors.HexColor("#16a34a"))
+    body_style = ParagraphStyle("Body", parent=styles["BodyText"], fontSize=10, spaceAfter=6)
+
+    elements.append(Paragraph("Bio Nexus \u2014 BLAST Results", title_style))
+    elements.append(Spacer(1, 12))
+
+    if sequence:
+        preview = sequence[:100] + ("..." if len(sequence) > 100 else "")
+        elements.append(Paragraph(f"<b>Query:</b> {preview}", body_style))
+
+    elements.append(Paragraph(f"<b>Hits found:</b> {result.get('count', 0)}", body_style))
+    elements.append(Spacer(1, 12))
+
+    hits = result.get("hits", [])
+    if not hits:
+        elements.append(Paragraph("No hits found.", body_style))
+        doc.build(elements)
+        return buffer.getvalue()
+
+    table_data = [["#", "Accession", "Description", "E-value", "Identity", "Coverage"]]
+    for i, hit in enumerate(hits[:20], 1):
+        desc = (hit.get("description", "")[:60] + "...") if len(hit.get("description", "")) > 60 else hit.get("description", "")
+        table_data.append([
+            str(i),
+            hit.get("accession", ""),
+            desc,
+            f"{hit.get('evalue', 0):.1e}",
+            f"{hit.get('identity_pct', 0)}%",
+            f"{hit.get('coverage_pct', 0)}%",
+        ])
+
+    col_widths = [0.4 * inch, 1.0 * inch, 2.5 * inch, 1.0 * inch, 0.8 * inch, 0.8 * inch]
+    t = Table(table_data, colWidths=col_widths, repeatRows=1)
+    t.setStyle(TableStyle([
+        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#16a34a")),
+        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+        ("FONTSIZE", (0, 0), (-1, 0), 9),
+        ("FONTSIZE", (0, 1), (-1, -1), 8),
+        ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+        ("ALIGN", (0, 0), (-1, -1), "LEFT"),
+        ("VALIGN", (0, 0), (-1, -1), "TOP"),
+        ("GRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#e5e7eb")),
+        ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f9fafb")]),
+        ("TOPPADDING", (0, 0), (-1, -1), 4),
+        ("BOTTOMPADDING", (0, 0), (-1, -1), 4),
+        ("LEFTPADDING", (0, 0), (-1, -1), 4),
+        ("RIGHTPADDING", (0, 0), (-1, -1), 4),
+    ]))
+    elements.append(t)
+    elements.append(Spacer(1, 16))
+
+    elements.append(Paragraph("Significance Guide", heading_style))
+    elements.append(Paragraph("\u2022 <b>E-value &lt; 1e-50</b>: Highly significant match", body_style))
+    elements.append(Paragraph("\u2022 <b>E-value 1e-5 to 1e-50</b>: Significant match", body_style))
+    elements.append(Paragraph("\u2022 <b>E-value &gt; 1e-5</b>: Weak or non-significant", body_style))
+    elements.append(Spacer(1, 8))
+    elements.append(Paragraph(f"<i>Generated by Bio Nexus Platform \u2014 {result.get('count', 0)} hits</i>", body_style))
+
+    doc.build(elements)
+    return buffer.getvalue()
+
+
+def export_uniprot_pdf(data: dict) -> bytes:
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4, topMargin=0.75 * inch, bottomMargin=0.75 * inch)
+    styles = getSampleStyleSheet()
+    elements = []
+
+    title_style = ParagraphStyle("Title2", parent=styles["Title"], fontSize=16, spaceAfter=12)
+    heading_style = ParagraphStyle("Heading", parent=styles["Heading2"], fontSize=12, spaceAfter=6, textColor=colors.HexColor("#16a34a"))
+    body_style = ParagraphStyle("Body", parent=styles["BodyText"], fontSize=10, spaceAfter=6)
+
+    elements.append(Paragraph("Bio Nexus \u2014 UniProt Annotation", title_style))
+    elements.append(Spacer(1, 12))
+
+    elements.append(Paragraph(f"<b>Protein:</b> {data.get('full_name', 'Unknown')}", body_style))
+    elements.append(Paragraph(f"<b>Accession:</b> {data.get('accession', '')}", body_style))
+    elements.append(Paragraph(f"<b>Organism:</b> {data.get('organism', 'Unknown')}", body_style))
+
+    genes = data.get("gene_names", [])
+    if genes:
+        elements.append(Paragraph(f"<b>Gene:</b> {', '.join(genes)}", body_style))
+
+    ec = data.get("ec_number", "")
+    if ec:
+        elements.append(Paragraph(f"<b>EC Number:</b> {ec}", body_style))
+
+    elements.append(Paragraph(f"<b>Sequence Length:</b> {data.get('sequence_length', 0)} amino acids", body_style))
+    elements.append(Spacer(1, 12))
+
+    functions = data.get("functions", [])
+    if functions:
+        elements.append(Paragraph("Function", heading_style))
+        for f in functions:
+            elements.append(Paragraph(f, body_style))
+
+    locations = data.get("subcellular_locations", [])
+    if locations:
+        elements.append(Paragraph("Subcellular Location", heading_style))
+        elements.append(Paragraph(", ".join(locations), body_style))
+
+    pdb_ids = data.get("pdb_ids", [])
+    if pdb_ids:
+        elements.append(Paragraph("PDB Structures", heading_style))
+        elements.append(Paragraph(", ".join(pdb_ids), body_style))
+
+    keywords = data.get("keywords", [])
+    if keywords:
+        elements.append(Paragraph("Keywords", heading_style))
+        elements.append(Paragraph(", ".join(keywords[:10]), body_style))
+
+    elements.append(Spacer(1, 12))
+    elements.append(Paragraph("<i>Generated by Bio Nexus Platform</i>", body_style))
+
+    doc.build(elements)
+    return buffer.getvalue()

bioai-platform/backend/app/services/rate_limit.py

@@ -0,0 +1,27 @@
+from datetime import date
+from app.services.redis import get_redis
+from app.config import settings
+
+
+async def check_daily_limit(user_id: str = "anonymous") -> bool:
+    r = get_redis()
+    if not r:
+        return True
+
+    today = date.today().isoformat()
+    key = f"rate_limit:daily:{user_id}:{today}"
+    count = r.get(key)
+
+    if count is None:
+        r.setex(key, 86400, 1)
+        return True
+
+    if int(count) >= settings.DAILY_LIMIT:
+        return False
+
+    r.incr(key)
+    return True
+
+
+class RateLimitExceededError(Exception):
+    pass

bioai-platform/backend/app/services/redis.py

@@ -0,0 +1,15 @@
+import redis
+from app.config import settings
+
+_r = None
+
+
+def get_redis():
+    global _r
+    if _r is None:
+        try:
+            _r = redis.from_url(settings.REDIS_URL, decode_responses=True)
+            _r.ping()
+        except Exception:
+            _r = None
+    return _r

bioai-platform/backend/app/services/supabase.py

@@ -0,0 +1,11 @@
+from supabase import create_client, Client
+from app.config import settings
+
+_supabase: Client | None = None
+
+
+def get_supabase() -> Client:
+    global _supabase
+    if _supabase is None:
+        _supabase = create_client(settings.SUPABASE_URL, settings.SUPABASE_SERVICE_ROLE_KEY)
+    return _supabase

bioai-platform/backend/app/services/validators.py

@@ -0,0 +1,43 @@
+from Bio import SeqIO
+from io import StringIO
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class ValidationResult:
+    valid: bool = True
+    error: str = ""
+    sequences: List = field(default_factory=list)
+
+
+def validate_fasta(text: str, tool: str = "blast") -> ValidationResult:
+    if not text or not text.strip():
+        return ValidationResult(valid=False, error="Empty sequence")
+
+    # Try parsing as FASTA
+    try:
+        records = list(SeqIO.parse(StringIO(text), "fasta"))
+    except Exception:
+        records = []
+
+    if records:
+        for rec in records:
+            seq_str = str(rec.seq)
+            if len(seq_str) < 6:
+                return ValidationResult(valid=False, error=f"Sequence too short: {len(seq_str)} residues")
+            if not set(seq_str.upper()).issubset(set("ACDEFGHIKLMNPQRSTVWY")):
+                return ValidationResult(valid=False, error="Invalid amino acid characters found")
+        return ValidationResult(sequences=records)
+
+    # Plain sequence (no FASTA header)
+    clean = "".join(c for c in text if c.isalpha()).upper()
+    if len(clean) < 6:
+        return ValidationResult(valid=False, error=f"Sequence too short: {len(clean)} residues")
+    if not set(clean).issubset(set("ACDEFGHIKLMNPQRSTVWY")):
+        return ValidationResult(valid=False, error="Invalid amino acid characters found")
+
+    from Bio.Seq import Seq
+    from Bio.SeqRecord import SeqRecord
+    record = SeqRecord(Seq(clean), id="query", description="")
+    return ValidationResult(sequences=[record])

bioai-platform/backend/app/tools/alphafold.py

@@ -0,0 +1,44 @@
+import httpx
+from typing import Any
+from app.tools.base import BaseTool
+from app.config import settings
+from app.services.cache import ttl_cache
+
+
+class AlphaFoldTool(BaseTool):
+    name = "alphafold"
+
+    @ttl_cache(ttl=86400, prefix="alphafold")
+    async def run(self, input: dict) -> dict:
+        uniprot_accession = input.get("uniprot_accession", "").strip()
+        if not uniprot_accession:
+            return {"error": "No UniProt accession provided", "structure_available": False}
+
+        result = await self._lookup(uniprot_accession)
+        return result
+
+    async def _lookup(self, accession: str) -> dict:
+        url = f"{settings.ALPHAFOLD_DB_URL}/{accession}"
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.get(url)
+            if resp.status_code == 404:
+                return {
+                    "uniprot_accession": accession,
+                    "structure_available": False,
+                    "message": "No AlphaFold prediction available for this protein",
+                    "pdb_url": None,
+                    "cif_url": None,
+                    "confidence": None,
+                }
+            resp.raise_for_status()
+            data = resp.json()
+            entry = data[0] if isinstance(data, list) else data
+            return {
+                "uniprot_accession": accession,
+                "structure_available": True,
+                "pdb_url": entry.get("pdbUrl", ""),
+                "cif_url": entry.get("cifUrl", ""),
+                "confidence": entry.get("confidenceScore", None),
+                "model_created_date": entry.get("modelCreatedDate", ""),
+                "latest_version": entry.get("latestVersion", 0),
+            }

bioai-platform/backend/app/tools/base.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseTool(ABC):
+    name: str = ""
+
+    @abstractmethod
+    async def run(self, input: dict) -> dict:
+        ...
+
+    def requires_input_from(self) -> list[str]:
+        return []
+
+    def provides_output_to(self) -> list[str]:
+        return []

bioai-platform/backend/app/tools/blast.py

@@ -0,0 +1,80 @@
+import httpx
+import asyncio
+import hashlib
+import json
+from typing import Any
+from app.tools.base import BaseTool
+from app.config import settings
+from app.services.cache import ttl_cache
+
+
+class BlastTool(BaseTool):
+    name = "blast"
+
+    POLL_INTERVAL = 2.0
+    MAX_POLL_TIME = 120
+
+    @ttl_cache(ttl=86400, prefix="blast")
+    async def run(self, input: dict) -> dict:
+        sequence = input.get("sequence", "").strip()
+        database = input.get("database", "uniprotkb_swissprot")
+        program = input.get("program", "blastp")
+        max_hits = input.get("max_hits", 10)
+
+        job_id = await self._submit(sequence, program, database)
+        status = await self._poll(job_id)
+        if status != "FINISHED":
+            return {"error": f"BLAST job {job_id} ended with status {status}", "hits": []}
+
+        hits = await self._fetch_results(job_id)
+        parsed = self._parse_hits(hits, max_hits)
+        return {"hits": parsed, "count": len(parsed), "source": "EBI BLAST", "database": database}
+
+    async def _submit(self, sequence: str, program: str, database: str) -> str:
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.post(
+                f"{settings.EBI_BASE_URL}/run",
+                data={"email": "user@bio-nexus.app", "sequence": sequence, "program": program, "database": database},
+            )
+            resp.raise_for_status()
+            return resp.text.strip()
+
+    async def _poll(self, job_id: str) -> str:
+        start = asyncio.get_event_loop().time()
+        async with httpx.AsyncClient(timeout=10) as client:
+            while True:
+                elapsed = asyncio.get_event_loop().time() - start
+                if elapsed > self.MAX_POLL_TIME:
+                    return "TIMEOUT"
+                resp = await client.get(f"{settings.EBI_BASE_URL}/status/{job_id}")
+                resp.raise_for_status()
+                status = resp.text.strip()
+                if status in ("FINISHED", "ERROR", "FAILED"):
+                    return status
+                await asyncio.sleep(self.POLL_INTERVAL)
+
+    async def _fetch_results(self, job_id: str) -> list[dict]:
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.get(f"{settings.EBI_BASE_URL}/result/{job_id}/json")
+            resp.raise_for_status()
+            data = resp.json()
+            return data.get("hits", [])
+
+    def _parse_hits(self, raw_hits: list[dict], max_hits: int) -> list[dict]:
+        parsed = []
+        for hit in raw_hits[:max_hits]:
+            hsps = hit.get("hsps", [{}])[0] if hit.get("hsps") else {}
+            parsed.append({
+                "accession": hit.get("hit_acc", ""),
+                "id": hit.get("hit_id", ""),
+                "description": hit.get("hit_desc", ""),
+                "evalue": hsps.get("hsp_expect", 0),
+                "bit_score": hsps.get("hsp_bit_score", 0),
+                "identity_pct": hsps.get("hsp_identity", 0),
+                "alignment_length": hsps.get("hsp_align_len", 0),
+                "query_from": hsps.get("hsp_query_from", 0),
+                "query_to": hsps.get("hsp_query_to", 0),
+                "hit_from": hsps.get("hsp_hit_from", 0),
+                "hit_to": hsps.get("hsp_hit_to", 0),
+            })
+        return parsed

bioai-platform/backend/app/tools/registration.py

@@ -0,0 +1,10 @@
+from app.tools.blast import BlastTool
+from app.tools.uniprot import UniprotTool
+from app.tools.alphafold import AlphaFoldTool
+from app.pipeline.registry import registry
+
+
+def register_all_tools():
+    registry.register(BlastTool())
+    registry.register(UniprotTool())
+    registry.register(AlphaFoldTool())

bioai-platform/backend/app/tools/uniprot.py

@@ -0,0 +1,102 @@
+import httpx
+from typing import Any
+from app.tools.base import BaseTool
+from app.config import settings
+from app.services.cache import ttl_cache
+
+
+class UniprotTool(BaseTool):
+    name = "uniprot"
+
+    @ttl_cache(ttl=86400, prefix="uniprot")
+    async def run(self, input: dict) -> dict:
+        accession = input.get("accession", "").strip()
+        if not accession:
+            return {"error": "No accession provided"}
+
+        data = await self._fetch(accession)
+        if "error" in data:
+            return data
+
+        return {
+            "accession": data.get("primaryAccession", ""),
+            "full_name": self._extract_name(data),
+            "ec_number": (data.get("proteinDescription", {}) or {}).get("ecNumbers", [{}])[0].get("ecNumber", "") if data.get("proteinDescription") else "",
+            "gene_names": [g.get("geneName", {}).get("value", "") for g in (data.get("genes") or []) if g.get("geneName")],
+            "organism": ((data.get("organism", {}) or {}).get("scientificName", "")),
+            "functions": self._extract_functions(data),
+            "keywords": [kw.get("name", "") for kw in (data.get("keywords") or [])],
+            "sequence_length": ((data.get("sequence", {}) or {}).get("length", 0)),
+            "subcellular_locations": self._extract_locations(data),
+            "pdb_ids": self._extract_pdb(data),
+            "features": self._extract_features(data),
+            "go_terms": self._extract_go_terms(data),
+        }
+
+    async def _fetch(self, accession: str) -> dict:
+        url = f"{settings.UNIPROT_BASE_URL}/{accession}"
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.get(url, params={"format": "json"})
+            if resp.status_code == 404:
+                return {"error": f"Accession {accession} not found"}
+            resp.raise_for_status()
+            return resp.json()
+
+    def _extract_name(self, data: dict) -> str:
+        desc = data.get("proteinDescription", {}) or {}
+        rec_name = desc.get("recommendedName", {}) or {}
+        return (rec_name.get("fullName", {}) or {}).get("value", "")
+
+    def _extract_functions(self, data: dict) -> list[str]:
+        comments = data.get("comments") or []
+        funcs = []
+        for c in comments:
+            if c.get("commentType") == "FUNCTION":
+                texts = c.get("texts") or []
+                for t in texts:
+                    val = (t.get("value") or "").strip()
+                    if val:
+                        funcs.append(val)
+        return funcs
+
+    def _extract_locations(self, data: dict) -> list[str]:
+        comments = data.get("comments") or []
+        locs = []
+        for c in comments:
+            if c.get("commentType") == "SUBCELLULAR_LOCATION":
+                subcels = c.get("subcellularLocations") or []
+                for s in subcels:
+                    loc = (s.get("location", {}) or {}).get("value", "")
+                    if loc:
+                        locs.append(loc)
+        return locs
+
+    def _extract_pdb(self, data: dict) -> list[str]:
+        refs = data.get("uniProtKBCrossReferences") or []
+        pdbs = []
+        for r in refs:
+            if r.get("database") == "PDB":
+                pdbs.append(r.get("id", ""))
+        return pdbs
+
+    def _extract_features(self, data: dict) -> list[dict]:
+        features = data.get("features") or []
+        result = []
+        for f in features:
+            result.append({
+                "type": f.get("type", ""),
+                "description": f.get("description", ""),
+                "begin": (f.get("location", {}) or {}).get("start", {}).get("value"),
+                "end": (f.get("location", {}) or {}).get("end", {}).get("value"),
+            })
+        return result
+
+    def _extract_go_terms(self, data: dict) -> list[str]:
+        refs = data.get("uniProtKBCrossReferences") or []
+        go = []
+        for r in refs:
+            if r.get("database") == "GO":
+                term = r.get("properties", [{}])[0].get("value", "") if r.get("properties") else ""
+                if term:
+                    go.append(term)
+        return go

bioai-platform/backend/app/workers/celery_app.py

@@ -0,0 +1,22 @@
+try:
+    from celery import Celery
+    from app.config import settings
+
+    celery_app = Celery(
+        "bio_nexus",
+        broker=settings.CELERY_BROKER_URL,
+        backend=settings.CELERY_RESULT_BACKEND,
+    )
+
+    celery_app.conf.update(
+        task_serializer="json",
+        accept_content=["json"],
+        result_serializer="json",
+        timezone="UTC",
+        enable_utc=True,
+        task_track_started=True,
+        task_acks_late=True,
+        worker_prefetch_multiplier=1,
+    )
+except ImportError:
+    celery_app = None

bioai-platform/backend/app/workers/pipeline_worker.py

@@ -0,0 +1,57 @@
+import asyncio
+from app.workers.celery_app import celery_app
+from app.pipeline.engine import PipelineEngine
+from app.services.supabase import get_supabase
+from datetime import datetime, timezone
+
+
+def run_pipeline_sync(job_id: str, sequence: str, database: str, max_hits: int) -> dict:
+    """Run pipeline synchronously (used when Celery is unavailable)."""
+    supabase = get_supabase()
+    try:
+        supabase.table("jobs").update({
+            "status": "running",
+            "progress_pct": 10,
+        }).eq("id", job_id).execute()
+
+        async def execute():
+            engine = PipelineEngine()
+            return await engine.execute(sequence, database, max_hits)
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(execute())
+        loop.close()
+
+        if "error" in result:
+            supabase.table("jobs").update({
+                "status": "failed",
+                "error": result["error"],
+                "completed_at": datetime.now(timezone.utc).isoformat(),
+            }).eq("id", job_id).execute()
+            return {"status": "failed", "error": result["error"]}
+
+        context = result.get("context", {})
+        supabase.table("jobs").update({
+            "status": "complete",
+            "progress_pct": 100,
+            "context_json": context,
+            "steps_completed": result.get("steps_completed", []),
+            "completed_at": datetime.now(timezone.utc).isoformat(),
+        }).eq("id", job_id).execute()
+
+        return {"status": "complete", "job_id": job_id}
+
+    except Exception as exc:
+        supabase.table("jobs").update({
+            "status": "failed",
+            "error": str(exc)[:500],
+            "completed_at": datetime.now(timezone.utc).isoformat(),
+        }).eq("id", job_id).execute()
+        return {"status": "failed", "error": str(exc)}
+
+
+if celery_app is not None:
+    @celery_app.task(bind=True, max_retries=2, default_retry_delay=30)
+    def run_pipeline_job(self, job_id: str, sequence: str, database: str, max_hits: int):
+        return run_pipeline_sync(job_id, sequence, database, max_hits)

bioai-platform/backend/requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+slowapi
+redis
+httpx
+biopython
+litellm
+python-dotenv
+supabase
+reportlab
+celery
+pydantic[email]

bioai-platform/frontend/.env.local.example

@@ -0,0 +1,3 @@
+NEXT_PUBLIC_SUPABASE_URL=
+NEXT_PUBLIC_SUPABASE_ANON_KEY=
+SUPABASE_SERVICE_ROLE_KEY=

bioai-platform/frontend/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.

bioai-platform/frontend/next.config.js

@@ -0,0 +1,13 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  async rewrites() {
+    return [
+      {
+        source: '/api/backend/:path*',
+        destination: 'http://localhost:8000/:path*',
+      },
+    ];
+  },
+};
+
+module.exports = nextConfig;

bioai-platform/frontend/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "bionexus-frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@supabase/ssr": "^0.12.0",
+    "@supabase/supabase-js": "^2.49.4",
+    "axios": "^1.7.9",
+    "lucide-react": "^0.474.0",
+    "next": "^14.2.23",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-hot-toast": "^2.5.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.4",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "autoprefixer": "^10.4.20",
+    "eslint": "^8.56.0",
+    "eslint-config-next": "^14.2.23",
+    "postcss": "^8.5.2",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5.7.3"
+  }
+}