Build 5 AI Portfolio Projects That Get Interviews in 2026

# core/rag_chain.py
from langchain.vectorstores import Pinecone
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA

def create_rag_chain(index_name: str):
    # Use text-embedding-3-small for cost efficiency
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    
    vectorstore = Pinecone.from_existing_index(
        index_name=index_name,
        embedding=embeddings
    )
    
    # GPT-4o-mini balances quality and cost
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
    
    return RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",  # Passes all context at once
        retriever=vectorstore.as_retriever(
            search_kwargs={"k": 4}  # Top 4 most relevant chunks
        ),
        return_source_documents=True  # Show sources to users
    )

# Use Streamlit Cloud for free hosting
pip install streamlit langchain pinecone-client openai

# Test locally
streamlit run app.py

# Deploy to Streamlit Cloud (connects to GitHub)
# Add secrets in dashboard: OPENAI_API_KEY, PINECONE_KEY

# train.py
import timm
import torch
from torch.utils.data import DataLoader
from torchvision import transforms

def create_model(num_classes: int, pretrained: bool = True):
    # ConvNeXt V2 outperforms ViT on small datasets
    model = timm.create_model(
        'convnextv2_base',
        pretrained=pretrained,
        num_classes=num_classes
    )
    return model

# Use aggressive augmentation for small datasets
train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(0.3, 0.3, 0.3),  # Handles lighting variation
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                       std=[0.229, 0.224, 0.225])
])

# Train with mixed precision for speed
scaler = torch.cuda.amp.GradScaler()
for batch in train_loader:
    with torch.cuda.amp.autocast():
        loss = criterion(model(images), labels)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

# app.py - Gradio interface
import gradio as gr
import torch

model = torch.load('best_model.pth')
model.eval()

def predict(image):
    # Preprocess and predict
    pred = model(preprocess(image))
    probs = torch.softmax(pred, dim=1)
    
    # Return top 3 predictions with confidence
    return {
        classes[i]: float(probs[0][i]) 
        for i in probs.topk(3).indices[0]
    }

demo = gr.Interface(
    fn=predict,
    inputs=gr.Image(type="pil"),
    outputs=gr.Label(num_top_classes=3),
    examples=["examples/sample1.jpg", "examples/sample2.jpg"],
    title="Industrial Defect Classifier",
    description="Trained on 5,000 manufacturing images. Detects scratches, dents, and discoloration."
)

demo.launch()

pip install gradio torch timm
huggingface-cli login
python app.py  # Test locally
# Push to HF Space via git

# reviewer.py
import openai
from github import Github

REVIEW_PROMPT = """You are a senior engineer reviewing code. Analyze this diff and provide:
1. Security issues (SQL injection, XSS, secrets in code)
2. Performance problems (N+1 queries, inefficient algorithms)
3. Code quality (naming, complexity, error handling)

Be specific. Reference line numbers. Suggest fixes.

Diff:
{diff}

Format as JSON:
{{
  "security": [...],
  "performance": [...],
  "quality": [...]
}}"""

def review_pr(repo_name: str, pr_number: int):
    g = Github(GITHUB_TOKEN)
    repo = g.get_repo(repo_name)
    pr = repo.get_pull(pr_number)
    
    # Get diff for changed files
    files = pr.get_files()
    diff = "\n".join([f.patch for f in files if f.patch])
    
    # Use GPT-4o for code reasoning
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": REVIEW_PROMPT.format(diff=diff)
        }],
        response_format={"type": "json_object"}  # Forces valid JSON
    )
    
    review = response.choices[0].message.content
    
    # Post as PR comment
    pr.create_issue_comment(format_review(review))

# .github/workflows/ai-review.yml
name: AI Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run AI Reviewer
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          pip install openai PyGithub
          python reviewer.py ${{ github.repository }} ${{ github.event.pull_request.number }}

# recommender.py
import faiss
import numpy as np
from sentence_transformers import SentenceTransformer

class HybridRecommender:
    def __init__(self):
        # Use lightweight embedding model
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
        
        # FAISS for fast similarity search
        self.index = faiss.IndexFlatIP(384)  # Inner product for cosine sim
        
    def add_items(self, items: list[dict]):
        """Items have 'id', 'title', 'description'"""
        texts = [f"{i['title']} {i['description']}" for i in items]
        embeddings = self.encoder.encode(texts, normalize_embeddings=True)
        
        self.index.add(embeddings.astype('float32'))
        self.items = items
        
    def recommend(self, user_history: list[str], k: int = 10):
        # Encode user's interaction history
        history_text = " ".join(user_history)
        query_embedding = self.encoder.encode(
            [history_text],
            normalize_embeddings=True
        )
        
        # Find similar items
        scores, indices = self.index.search(
            query_embedding.astype('float32'),
            k * 2  # Get extras to filter out already seen
        )
        
        # Filter and rank
        recommendations = []
        for idx, score in zip(indices[0], scores[0]):
            item = self.items[idx]
            if item['id'] not in user_history:
                recommendations.append({
                    **item,
                    'score': float(score)
                })
                if len(recommendations) >= k:
                    break
                    
        return recommendations

# Use Redis to track user interactions
import redis

r = redis.Redis()

def log_interaction(user_id: str, item_id: str, interaction_type: str):
    # Store in Redis sorted set with timestamp as score
    r.zadd(
        f"user:{user_id}:history",
        {item_id: time.time()}
    )
    
    # Keep only last 50 interactions
    r.zremrangebyrank(f"user:{user_id}:history", 0, -51)

def get_personalized_recs(user_id: str):
    # Get recent interactions
    recent = r.zrange(f"user:{user_id}:history", 0, -1)
    
    # Use collaborative filtering + content-based
    cf_recs = collaborative_filter(user_id)
    content_recs = recommender.recommend([item.decode() for item in recent])
    
    # Blend both (70% content, 30% collaborative)
    return blend_recommendations(content_recs, cf_recs, weights=[0.7, 0.3])

# Backend: FastAPI on Railway
pip install fastapi sentence-transformers faiss-cpu redis

# Frontend: Next.js on Vercel
npx create-next-app@latest rec-engine
# Build UI showing recommendations with "like/dislike" buttons

# stream_processor.py
import asyncio
import json
from redis import asyncio as aioredis
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def analyze_sentiment(text: str) -> dict:
    # Use structured output for consistent parsing
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{
            "role": "system",
            "content": "Analyze sentiment. Return JSON with 'sentiment' (positive/negative/neutral), 'confidence' (0-1), and 'topics' (list of key topics)."
        }, {
            "role": "user",
            "content": text
        }],
        response_format={"type": "json_object"}
    )
    
    return json.loads(response.choices[0].message.content)

async def process_stream():
    redis = await aioredis.from_url("redis://localhost")
    
    while True:
        # Read from Redis stream
        messages = await redis.xread(
            {"social_media": "$"},  # $ means new messages only
            count=10,
            block=1000  # Wait 1 second for new data
        )
        
        for stream, data in messages:
            for msg_id, msg in data:
                text = msg[b'text'].decode()
                
                # Analyze sentiment
                analysis = await analyze_sentiment(text)
                
                # Store results
                await redis.hset(
                    f"analysis:{msg_id}",
                    mapping=analysis
                )
                
                # Publish to WebSocket clients
                await redis.publish(
                    "sentiment_updates",
                    json.dumps(analysis)
                )

// components/SentimentDashboard.tsx
'use client';

import { useEffect, useState } from 'react';
import { LineChart, Line, XAxis, YAxis } from 'recharts';

export default function SentimentDashboard() {
  const [data, setData] = useState<Array<{time: string, positive: number, negative: number}>>([]);
  
  useEffect(() => {
    // Connect to WebSocket
    const ws = new WebSocket('ws://localhost:8000/ws');
    
    ws.onmessage = (event) => {
      const analysis = JSON.parse(event.data);
      
      setData(prev => {
        const updated = [...prev, {
          time: new Date().toLocaleTimeString(),
          positive: analysis.sentiment === 'positive' ? 1 : 0,
          negative: analysis.sentiment === 'negative' ? 1 : 0
        }];
        
        // Keep last 100 points
        return updated.slice(-100);
      });
    };
    
    return () => ws.close();
  }, []);
  
  return (
    <div className="p-8">
      <h1 className="text-2xl font-bold mb-4">Live Sentiment Analysis</h1>
      
      <LineChart width={800} height={400} data={data}>
        <XAxis dataKey="time" />
        <YAxis />
        <Line type="monotone" dataKey="positive" stroke="#10b981" />
        <Line type="monotone" dataKey="negative" stroke="#ef4444" />
      </LineChart>
      
      <div className="mt-8 grid grid-cols-3 gap-4">
        {/* Show top trending topics, recent mentions, sentiment breakdown */}
      </div>
    </div>
  );
}

# Backend: FastAPI + Redis on Railway
uvicorn main:app --reload

# Frontend: Next.js on Vercel
npm run build && vercel deploy

# Data ingestion: Python script fetching from Twitter API
python ingest_tweets.py --keyword "AI" --stream

# [Project Name]

**[One-sentence value proposition]**

🔗 [Live Demo](https://...) | 📹 [Video](https://...) | 💻 [Code](https://github.com/...)

## What It Does

[2-3 sentences. Focus on USER value, not tech stack]

**Key Features:**
- Feature that solves real problem
- Metric that proves it works
- Differentiator from existing solutions

## Tech Stack

- **AI-ML:** GPT-4o, LangChain, PyTorch
- **Backend:** FastAPI, Redis, PostgreSQL  
- **Frontend:** Next.js, Tailwind, Recharts
- **Deploy:** Vercel, Railway, Pinecone

## Technical Challenges

### [Challenge 1: e.g., "Reducing RAG latency from 8s to 2s"]

**Problem:** [Why this mattered]

**Solution:** [What you tried, what worked]

**Result:** [Metrics showing improvement]

## Architecture

[Simple diagram showing data flow]

## Lessons Learned

- What worked better than expected
- What you'd do differently next time
- What you want to explore further

## Metrics

- **Accuracy:** 94% on test set (n=1,000)
- **Latency:** p50 1.2s, p99 3.1s
- **Cost:** $0.05 per user per month
- **Users:** 50 beta testers, 85% retention

## Future Work

- [ ] Realistic improvement you'd add
- [ ] Another feature users requested
- [ ] Technical debt you'd address

---

*Built in 5 days. Last updated: Feb 2026. Tested on Chrome/Safari, mobile-responsive.*

<!-- Above the fold -->
<h1>Your Name - AI Engineer</h1>
<p>I build production AI systems that [specific value]. Previously [impressive thing].</p>

<!-- 3 best projects with thumbnails -->
<div class="projects-grid">
  <ProjectCard 
    title="RAG Documentation Bot"
    description="Used by 50+ developers daily"
    metrics="94% answer accuracy, <2s response time"
    demo="https://..."
    video="https://..."
  />
</div>

<!-- Quick contact -->
<a href="mailto:you@email.com">Email</a> | 
<a href="/resume.pdf">Resume</a> |
<a href="https://github.com/...">GitHub</a>