added few files

misc/JOB_SEARCH_SCHEDULE.md

@@ -0,0 +1,468 @@
+# Job Search Schedule: February 1 - June 1, 2026
+
+**Goal:** Land a $150k+ Applied AI/ML Engineer role before OPT grace period ends.
+
+---
+
+## Daily Structure
+
+| Time | Activity |
+|------|----------|
+| 5:00 AM | Wake up |
+| 5:00 - 6:00 AM | Morning routine, coffee |
+| 6:00 - 9:00 AM | **Deep Work Block 1** (LeetCode/Technical) |
+| 9:00 - 9:30 AM | Break |
+| 9:30 - 12:30 PM | **Deep Work Block 2** (Learning/Projects) |
+| 12:30 - 1:30 PM | Lunch |
+| 1:30 - 4:30 PM | **Deep Work Block 3** (Job Applications/Networking) |
+| 4:30 - 7:00 PM | Gym (2.5 hours) |
+| 7:00 - 8:00 PM | Dinner |
+| 8:00 - 10:00 PM | Light work (applications, reading, prep) |
+| 10:00 - 11:00 PM | Wind down |
+| 11:00 PM | Sleep |
+
+**Tuesday Exception:** Class 7-10 PM (no gym, shift blocks earlier)
+
+---
+
+## Phase Overview
+
+| Phase | Weeks | Focus |
+|-------|-------|-------|
+| **Phase 1** | Week 1-4 (Feb) | Foundation + Start Applications |
+| **Phase 2** | Week 5-8 (Mar) | LangChain + Interview Prep Ramp |
+| **Phase 3** | Week 9-12 (Apr) | System Design + Mock Interviews |
+| **Phase 4** | Week 13-17 (May-Jun 1) | Interview Mode + Final Push |
+
+---
+
+# PHASE 1: Foundation (February)
+
+## Week 1: Feb 1-7
+### Theme: Finish Agent Framework + Start Everything
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | Agent Framework | Agent Framework | Agent Framework | Agent Framework | Agent Framework | Review week | Rest |
+| 1:30-4:30 | Resume update | 5 applications | 5 applications | 5 applications | 5 applications | Network LinkedIn | Rest |
+| 8-10 PM | ML review | (Class) | ML review | ML review | ML review | Applications | Rest |
+
+### Deliverables Week 1:
+- [ ] Agent framework 100% complete
+- [ ] LeetCode: 12 problems solved (Arrays, Strings focus)
+- [ ] Resume updated with agent framework project
+- [ ] 20+ job applications submitted
+- [ ] LinkedIn profile updated
+- [ ] 5 LinkedIn connection requests to recruiters
+
+---
+
+## Week 2: Feb 8-14
+### Theme: LangChain Basics + Application Momentum
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | LangChain basics | LangChain basics | LangChain chains | LangChain chains | LangChain agents | Build project | Rest |
+| 1:30-4:30 | 5 applications | 5 applications | 5 applications | 5 applications | 5 applications | Network | Rest |
+| 8-10 PM | ML review | (Class) | ML review | ML review | ML review | Behavioral prep | Rest |
+
+### Deliverables Week 2:
+- [ ] LeetCode: 12 more problems (Total: 24) - Trees, Linked Lists
+- [ ] LangChain fundamentals understood (chains, prompts, output parsers)
+- [ ] 25+ job applications submitted (Total: 45+)
+- [ ] Started tracking applications in spreadsheet
+- [ ] 3 Pfizer contacts messaged for referrals
+
+---
+
+## Week 3: Feb 15-21
+### Theme: LangGraph + First Responses
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | LangGraph basics | LangGraph state | LangGraph edges | LangGraph project | LangGraph project | Complete project | Rest |
+| 1:30-4:30 | 5 applications | 5 applications | 5 applications | 5 applications | 5 applications | Network | Rest |
+| 8-10 PM | ML review | (Class) | RAG concepts | RAG concepts | Project polish | Behavioral prep | Rest |
+
+### Deliverables Week 3:
+- [ ] LeetCode: 12 more problems (Total: 36) - Graphs, BFS/DFS
+- [ ] LangGraph multi-agent project complete
+- [ ] Project deployed (Streamlit or FastAPI)
+- [ ] 25+ applications (Total: 70+)
+- [ ] First phone screens scheduled (hopefully)
+- [ ] Pfizer STAR story written out
+
+---
+
+## Week 4: Feb 22-28
+### Theme: RAG Deep Dive + Interview Prep Start
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | RAG architecture | Vector DBs | Chunking strategies | Retrieval patterns | RAG evaluation | Build RAG project | Rest |
+| 1:30-4:30 | 5 applications | 5 applications | 5 applications | 5 applications | 5 applications | Mock interview | Rest |
+| 8-10 PM | Interview prep | (Class) | Interview prep | Interview prep | Interview prep | Rest | Rest |
+
+### Deliverables Week 4:
+- [ ] LeetCode: 12 more problems (Total: 48) - DP basics
+- [ ] RAG system built (with evaluation)
+- [ ] Added to portfolio
+- [ ] 25+ applications (Total: 95+)
+- [ ] First mock interview completed
+- [ ] ML fundamentals flashcards created
+
+---
+
+## February Checkpoint ✓
+
+**By Feb 28:**
+- [ ] 48+ LeetCode problems solved
+- [ ] Agent framework complete + deployed
+- [ ] LangGraph project complete + deployed
+- [ ] RAG project complete
+- [ ] 95+ job applications
+- [ ] 2-3 phone screens scheduled
+- [ ] Pfizer story polished
+
+---
+
+# PHASE 2: LangChain Mastery + Interview Ramp (March)
+
+## Week 5: Mar 1-7
+### Theme: Advanced RAG + Phone Screens
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | Self-correcting RAG | Multi-query RAG | Hybrid search | GraphRAG intro | GraphRAG build | Project polish | Rest |
+| 1:30-4:30 | Applications | Applications | Phone screen prep | Applications | Applications | Network | Rest |
+| 8-10 PM | ML interview Q's | (Class) | ML interview Q's | ML interview Q's | Behavioral prep | Rest | Rest |
+
+### Deliverables Week 5:
+- [ ] LeetCode: 12 more (Total: 60)
+- [ ] Advanced RAG patterns implemented
+- [ ] GraphRAG basic understanding
+- [ ] 20+ applications (Total: 115+)
+- [ ] 1-2 phone screens completed
+- [ ] ML fundamentals review: supervised learning
+
+---
+
+## Week 6: Mar 8-14
+### Theme: Production Patterns + Technical Screens
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | Streaming patterns | Fallback chains | Caching | Memory patterns | Production deploy | System design | Rest |
+| 1:30-4:30 | Applications | Applications | Applications | Applications | Applications | Mock interview | Rest |
+| 8-10 PM | DL/Transformer Q's | (Class) | DL/Transformer Q's | Interview prep | Interview prep | Rest | Rest |
+
+### Deliverables Week 6:
+- [ ] LeetCode: 12 more (Total: 72)
+- [ ] Production-ready LangChain app
+- [ ] Streaming + caching implemented
+- [ ] 20+ applications (Total: 135+)
+- [ ] 2 mock interviews completed
+- [ ] ML fundamentals review: deep learning basics
+
+---
+
+## Week 7: Mar 15-21
+### Theme: System Design Intro + More Interviews
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | ML System Design book | Design: Rec system | Design: Search | Design: RAG system | Design: Agent | Practice designs | Rest |
+| 1:30-4:30 | Applications | Applications | Applications | Applications | Applications | Mock interview | Rest |
+| 8-10 PM | RAG interview Q's | (Class) | Agent interview Q's | Interview prep | Interview prep | Rest | Rest |
+
+### Deliverables Week 7:
+- [ ] LeetCode: 12 more (Total: 84)
+- [ ] 3 ML system designs practiced
+- [ ] System design framework memorized
+- [ ] 20+ applications (Total: 155+)
+- [ ] Technical screen(s) completed
+- [ ] ML fundamentals review: NLP/Transformers
+
+---
+
+## Week 8: Mar 22-28
+### Theme: Interview Prep Intensity
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x3 | Rest |
+| 9:30-12:30 | System design practice | System design practice | ML interview Q's | ML interview Q's | Mock interview | Mock interview | Rest |
+| 1:30-4:30 | Applications | Applications | Applications | Applications | Applications | Rest | Rest |
+| 8-10 PM | Behavioral prep | (Class) | Behavioral prep | Interview prep | Rest | Rest | Rest |
+
+### Deliverables Week 8:
+- [ ] LeetCode: 12 more (Total: 96)
+- [ ] 5+ system designs practiced
+- [ ] 15+ applications (Total: 170+)
+- [ ] 3+ mock interviews total
+- [ ] Ready for technical rounds
+
+---
+
+## March Checkpoint ✓
+
+**By Mar 31:**
+- [ ] 96+ LeetCode problems solved
+- [ ] Advanced RAG + LangGraph projects complete
+- [ ] 5+ system designs practiced
+- [ ] 170+ total applications
+- [ ] 5+ phone/technical screens completed
+- [ ] On-site interviews scheduled (hopefully)
+
+---
+
+# PHASE 3: Interview Mode (April)
+
+## Week 9: Apr 1-7
+### Theme: Mock Interviews + Real Interviews
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | LeetCode x2 | Rest |
+| 9:30-12:30 | Mock coding | Mock system design | Mock ML | Interview prep | Interview prep | Mock full loop | Rest |
+| 1:30-4:30 | Applications | Applications | Applications | Applications | Applications | Rest | Rest |
+| 8-10 PM | Review weak areas | (Class) | Review weak areas | Prep for interviews | Prep for interviews | Rest | Rest |
+
+### Deliverables Week 9:
+- [ ] LeetCode: 10 more (Total: 106)
+- [ ] 2 full mock interview loops
+- [ ] 10+ applications (Total: 180+)
+- [ ] Identify and fix weak areas
+
+---
+
+## Week 10: Apr 8-14
+### Theme: On-sites Begin
+
+| Block | Mon | Tue | Wed | Thu | Fri | Sat | Sun |
+|-------|-----|-----|-----|-----|-----|-----|-----|
+| 6-9 AM | LeetCode x2 | Interview prep | LeetCode x2 | Interview prep | LeetCode x2 | Review | Rest |
+| 9:30-12:30 | Prep for specific company | INTERVIEW | Prep | INTERVIEW | Prep | Mock | Rest |
+| 1:30-4:30 | Applications | Follow-up | Applications | Follow-up | Applications | Rest | Rest |
+| 8-10 PM | Company research | (Class) | Company research | Behavioral prep | Rest | Rest | Rest |
+
+### Deliverables Week 10:
+- [ ] LeetCode: 6 more (Total: 112)
+- [ ] 2+ on-site/virtual on-site interviews
+- [ ] Thank you emails sent
+- [ ] Continue applications pipeline
+
+---
+
+## Week 11: Apr 15-21
+### Theme: Interview Sprint
+
+| Block | Focus |
+|-------|-------|
+| All week | Interviews, prep between interviews, light applications |
+
+### Deliverables Week 11:
+- [ ] 2-3 more interviews completed
+- [ ] Follow-up on all interviews
+- [ ] Continue pipeline
+
+---
+
+## Week 12: Apr 22-28
+### Theme: Interview Sprint Continues
+
+| Block | Focus |
+|-------|-------|
+| All week | Interviews, negotiations prep if offers coming |
+
+### Deliverables Week 12:
+- [ ] More interviews
+- [ ] Start seeing results (offers or rejections)
+- [ ] Learn from rejections, iterate
+
+---
+
+## April Checkpoint ✓
+
+**By Apr 30:**
+- [ ] 110+ LeetCode problems solved
+- [ ] 5-10 on-site interviews completed
+- [ ] 190+ total applications
+- [ ] Hopefully 1+ offers in pipeline
+- [ ] Clear understanding of weak areas
+
+---
+
+# PHASE 4: Final Push (May)
+
+## Week 13: May 1-7
+### Theme: Close Deals or Intensify Search
+
+**If you have offers:**
+- Negotiate
+- Compare offers
+- Make decision
+
+**If no offers yet:**
+- Analyze feedback from rejections
+- Intensify applications
+- More mock interviews
+
+### Deliverables Week 13:
+- [ ] Decision on any offers OR
+- [ ] 20+ more applications
+- [ ] More interviews scheduled
+
+---
+
+## Week 14: May 8-14
+### Theme: Pre-Graduation Push
+
+| Block | Focus |
+|-------|-------|
+| Continue interviews | Focus on closing |
+| Applications | Maintain pipeline |
+| Prep for graduation | Logistics |
+
+### Deliverables Week 14:
+- [ ] Interviews ongoing
+- [ ] Offer negotiations if applicable
+
+---
+
+## Week 15: May 15-21
+### Theme: Graduation Week
+
+| Block | Focus |
+|-------|-------|
+| May 23 | GRADUATION 🎓 |
+| Rest of week | Interviews, decisions |
+
+### Deliverables Week 15:
+- [ ] Graduate!
+- [ ] Close any pending offers
+- [ ] Prepare for OPT start
+
+---
+
+## Week 16: May 22-28
+### Theme: Post-Graduation, OPT Transition
+
+| Block | Focus |
+|-------|-------|
+| OPT paperwork | Get EAD card |
+| Interviews | Continue if needed |
+| Start date discussions | If offers accepted |
+
+### Deliverables Week 16:
+- [ ] OPT paperwork filed
+- [ ] Job offer accepted OR
+- [ ] Intensive job search continues
+
+---
+
+## Week 17: May 29 - Jun 1
+### Theme: June 1 Target
+
+### Deliverables:
+- [ ] **JOB OFFER ACCEPTED** (Target!)
+- [ ] Start date confirmed
+- [ ] OPT employment verified
+
+---
+
+# Tracking Spreadsheet
+
+Create a spreadsheet with these columns:
+
+| Company | Role | Applied Date | Status | Next Step | Notes |
+|---------|------|--------------|--------|-----------|-------|
+| Google | Applied AI Engineer | Feb 3 | Applied | Wait | Referral from X |
+| Anthropic | ML Engineer | Feb 5 | Phone Screen | Feb 15 | Prep RAG questions |
+
+---
+
+# Weekly Metrics to Track
+
+| Metric | Week 1 Target | Week 8 Target | Week 17 Target |
+|--------|---------------|---------------|----------------|
+| LeetCode Total | 12 | 96 | 120 |
+| Applications Total | 20 | 170 | 220 |
+| Phone Screens | 0 | 8 | 15 |
+| Technical Screens | 0 | 5 | 12 |
+| On-sites | 0 | 2 | 8 |
+| Offers | 0 | 0 | 1+ |
+
+---
+
+# Emergency Backup Plans
+
+## If no interviews by Week 6:
+- Resume review with mentor/professional
+- Expand to Tier 2/3 companies
+- More networking, less applications
+- Consider contracting roles
+
+## If no offers by Week 12:
+- Lower target salary temporarily
+- Consider smaller companies
+- Look at contract-to-hire roles
+- Leverage Pfizer network harder
+
+## If no offers by Week 16:
+- Start date flexibility with any offer
+- Consider any legitimate offer
+- Plan for extended search during OPT
+
+---
+
+# Resources to Use
+
+**LeetCode:**
+- NeetCode 150 (structured)
+- Grind 75 (time-efficient)
+- Company-specific lists
+
+**System Design:**
+- "Designing Machine Learning Systems" - Chip Huyen
+- "ML System Design Interview" - Ali Aminian
+- YouTube: System Design Interview channel
+
+**Behavioral:**
+- Write out 5 STAR stories
+- Pfizer project (main story)
+- Agent framework (technical depth)
+- Conflict resolution story
+- Failure and learning story
+
+**Mock Interviews:**
+- Pramp (free)
+- Interviewing.io (free/paid)
+- Friends/classmates
+
+---
+
+# Key Success Factors
+
+1. **Start applications NOW** - Don't wait until "ready"
+2. **Consistent LeetCode** - 2 problems/day minimum
+3. **Track everything** - Spreadsheet is your friend
+4. **Network aggressively** - Referrals > cold applications
+5. **Learn from rejections** - Ask for feedback
+6. **Stay healthy** - Gym, sleep, breaks matter
+
+---
+
+**You've got this. 4 months is enough with focused execution. Start today.**
+
+---
+
+*Last updated: February 1, 2026*
+

misc/tutorials/LANGCHAIN_LANGSERVE_PATTERNS.md

@@ -0,0 +1,782 @@
+# LangChain & LangServe: Advanced Patterns and Nuances
+
+A comprehensive reference for building production-ready agentic systems with LangChain and LangServe.
+
+---
+
+## Table of Contents
+
+1. [LangGraph - Stateful Agent Workflows](#1-langgraph---stateful-agent-workflows)
+2. [Agentic RAG Patterns](#2-agentic-rag-patterns)
+3. [Human-in-the-Loop Workflows](#3-human-in-the-loop-workflows)
+4. [Streaming Patterns](#4-streaming-patterns)
+5. [Fallback and Routing Chains](#5-fallback-and-routing-chains)
+6. [Structured Output Patterns](#6-structured-output-patterns)
+7. [Tool Orchestration](#7-tool-orchestration)
+8. [Multi-Agent Patterns](#8-multi-agent-patterns)
+9. [Production Patterns](#9-production-patterns)
+10. [Evaluation Patterns](#10-evaluation-patterns)
+11. [Advanced Memory Patterns](#11-advanced-memory-patterns)
+12. [Advanced Retrieval Patterns](#12-advanced-retrieval-patterns)
+13. [Callbacks and Observability](#13-callbacks-and-observability)
+14. [Dynamic Tool Generation](#14-dynamic-tool-generation)
+15. [Complex Chain Patterns](#15-complex-chain-patterns)
+16. [LangGraph Advanced Patterns](#16-langgraph-advanced-patterns)
+17. [Guardrails and Safety](#17-guardrails-and-safety)
+18. [Advanced Prompting Patterns](#18-advanced-prompting-patterns)
+19. [Testing Patterns](#19-testing-patterns)
+20. [LangServe Deployment Nuances](#20-langserve-deployment-nuances)
+
+---
+
+## 1. LangGraph - Stateful Agent Workflows
+
+LangGraph enables complex, stateful workflows with cycles and conditional routing.
+
+### Key Concepts
+- **StateGraph**: Define a graph with typed state that flows between nodes
+- **Nodes**: Functions that process and transform state
+- **Edges**: Connections between nodes (can be conditional)
+- **Cycles**: Loops in the graph for iterative refinement
+- **Checkpointing**: Persist state for resumption
+
+### What to Master
+- State management across nodes
+- Conditional edge routing based on state
+- Implementing cycles for iterative improvement
+- Human-in-the-loop breakpoints
+- State persistence and recovery
+- Subgraphs for modular workflows
+
+### Interview-Worthy Projects
+- Multi-agent research assistant with supervisor coordination
+- Self-correcting RAG with review loop
+- Code generation with test → fix → retry cycles
+
+---
+
+## 2. Agentic RAG Patterns
+
+Beyond basic RAG - agents that reason about retrieval.
+
+### Key Patterns
+
+**Self-Correcting RAG**
+- Initial retrieval
+- Generate answer
+- Self-check for hallucinations
+- Re-retrieve with refined query if needed
+
+**Query Transformation**
+- Query expansion (multiple variations)
+- Query decomposition (break into sub-queries)
+- Query refinement based on initial results
+
+**Adaptive Retrieval**
+- Decide when to retrieve vs use knowledge
+- Multi-hop reasoning for complex questions
+- Corrective RAG (re-retrieval on failure)
+
+**HyDE (Hypothetical Document Embeddings)**
+- Generate hypothetical answer first
+- Use it to retrieve similar real documents
+- Better semantic matching
+
+### What to Master
+- When to retrieve vs when to answer directly
+- How to evaluate retrieval quality
+- Multi-step retrieval strategies
+- Combining retrieval with reasoning
+
+---
+
+## 3. Human-in-the-Loop Workflows
+
+Real production systems need human oversight.
+
+### Key Patterns
+
+**Interrupts**
+- Pause execution at specific nodes
+- Wait for human approval
+- Resume with modified state if needed
+
+**State Persistence**
+- Save state across sessions
+- Allow humans to review async
+- Resume from any checkpoint
+
+**Approval Workflows**
+- Single approval gates
+- Multi-level approval chains
+- Conditional approval based on risk
+
+**Feedback Incorporation**
+- Collect human corrections
+- Learn from feedback
+- Improve over time
+
+### What to Master
+- Designing breakpoints in workflows
+- State serialization for persistence
+- Multi-turn approval processes
+- Feedback loop architecture
+
+---
+
+## 4. Streaming Patterns
+
+Not just streaming text - structured streaming for complex chains.
+
+### Key Patterns
+
+**Event Streaming**
+- Stream events from nested chains
+- Fine-grained control over what to stream
+- Different event types (tool start, LLM chunk, retriever end)
+
+**Progress Updates**
+- Stream status during long operations
+- Partial results as they become available
+- Error events for graceful handling
+
+**Multi-Agent Streaming**
+- Stream from multiple agents simultaneously
+- Coordinate streaming across agents
+- Aggregate and present coherently
+
+### What to Master
+- `astream_events()` for fine-grained control
+- Streaming in multi-agent systems
+- Progress updates during long operations
+- Partial results streaming
+- Error streaming and recovery
+
+---
+
+## 5. Fallback and Routing Chains
+
+Build resilient systems with intelligent routing.
+
+### Key Patterns
+
+**Fallback Chains**
+- Primary chain fails → try fallback
+- Multiple fallback levels
+- Graceful degradation
+
+**Semantic Routing**
+- Route based on query meaning
+- Different chains for different intents
+- Dynamic chain selection
+
+**Model Routing**
+- Simple queries → cheap model
+- Complex queries → powerful model
+- Cost-aware routing
+
+**Latency-Based Routing**
+- Fast model for time-sensitive queries
+- Slow model for quality-critical queries
+
+### What to Master
+- Designing fallback hierarchies
+- Semantic similarity for routing
+- Cost vs quality tradeoffs
+- Error handling at each level
+
+---
+
+## 6. Structured Output Patterns
+
+Getting reliable, typed outputs from LLMs.
+
+### Key Patterns
+
+**Pydantic Output Parsing**
+- Define schema with Pydantic
+- Parse LLM output into typed objects
+- Validation and error handling
+
+**Nested Structures**
+- Complex nested schemas
+- Lists and optional fields
+- Recursive structures
+
+**Partial Parsing for Streaming**
+- Parse incomplete JSON during streaming
+- Show progress while parsing
+- Handle malformed chunks
+
+**Error Recovery**
+- Retry on parse failure
+- Ask LLM to fix output
+- Fallback to simpler schema
+
+### What to Master
+- Designing robust schemas
+- Handling validation errors
+- Streaming with structured output
+- Combining multiple structured outputs
+
+---
+
+## 7. Tool Orchestration
+
+Advanced patterns for tool usage.
+
+### Key Patterns
+
+**Tool Dependencies**
+- Tools that call other tools
+- Sequential tool chains
+- Parallel tool execution
+
+**Conditional Tool Usage**
+- Select tools based on context
+- Skip tools when not needed
+- Dynamic tool availability
+
+**Tool Selection Strategies**
+- Semantic matching to select relevant tools
+- Limit tools based on query type
+- Dynamic tool generation
+
+**Tool Error Handling**
+- Retry failed tools
+- Fallback tools
+- Graceful degradation
+
+### What to Master
+- Designing tool interfaces
+- Managing tool dependencies
+- Error handling and retries
+- Tool result validation
+
+---
+
+## 8. Multi-Agent Patterns
+
+Coordinating multiple agents for complex tasks.
+
+### Key Patterns
+
+**Supervisor Pattern**
+- Manager agent coordinates workers
+- Routes tasks to appropriate agents
+- Synthesizes results
+
+**Debate Pattern**
+- Multiple agents discuss/debate
+- Reach consensus
+- Synthesize best answer
+
+**Pipeline Pattern**
+- Sequential agent handoffs
+- Each agent specializes
+- Pass context along
+
+**Hierarchical Teams**
+- Manager decomposes task
+- Workers execute subtasks
+- Manager synthesizes
+
+**Collaborative Agents**
+- Agents work together
+- Shared state
+- Complementary skills
+
+**Competitive Agents**
+- Multiple solutions
+- Evaluate and select best
+- Diverse approaches
+
+### What to Master
+- Agent communication protocols
+- State sharing strategies
+- Conflict resolution
+- Coordination overhead management
+
+---
+
+## 9. Production Patterns
+
+Building systems that work in the real world.
+
+### Key Patterns
+
+**Caching**
+- Semantic caching (similar queries → cached result)
+- Exact match caching
+- Cache invalidation strategies
+
+**Rate Limiting**
+- Per-user limits
+- Per-model limits
+- Graceful handling when limited
+
+**Retry Strategies**
+- Exponential backoff
+- Jitter to prevent thundering herd
+- Max retry limits
+
+**Cost Tracking**
+- Token usage per request
+- Cost per user/session
+- Budget enforcement
+
+**Batch Processing**
+- Batch similar requests
+- Efficient API usage
+- Queue management
+
+### What to Master
+- Caching strategies for LLM calls
+- Rate limiting architecture
+- Cost optimization
+- Monitoring and alerting
+
+---
+
+## 10. Evaluation Patterns
+
+Measuring and improving agent quality.
+
+### Key Patterns
+
+**LLM-as-Judge**
+- Use LLM to evaluate outputs
+- Define evaluation criteria
+- Score and compare
+
+**Custom Evaluators**
+- Domain-specific metrics
+- Task-specific evaluation
+- Automated scoring
+
+**A/B Testing**
+- Compare different agents
+- Statistical significance
+- User preference tracking
+
+**Regression Testing**
+- Maintain test suite
+- Detect regressions
+- Continuous evaluation
+
+**Human Feedback**
+- Collect user ratings
+- Incorporate corrections
+- Improve over time
+
+### What to Master
+- Designing evaluation criteria
+- Building test datasets
+- Interpreting evaluation results
+- Continuous improvement loops
+
+---
+
+## 11. Advanced Memory Patterns
+
+Beyond basic conversation memory.
+
+### Key Patterns
+
+**Cross-Session Memory**
+- Remember across conversations
+- User-specific memory
+- Relevant context retrieval
+
+**Entity Memory**
+- Track entities (people, places, things)
+- Update entity knowledge
+- Retrieve entity context
+
+**Summary + Buffer Hybrid**
+- Recent messages in full
+- Older messages summarized
+- Token-efficient
+
+**Vector Store Memory**
+- All conversations in vector DB
+- Semantic search for relevant context
+- Scalable long-term memory
+
+### What to Master
+- Memory type selection
+- Token budget management
+- Memory persistence
+- Privacy considerations
+
+---
+
+## 12. Advanced Retrieval Patterns
+
+Sophisticated retrieval strategies.
+
+### Key Patterns
+
+**Multi-Query Retrieval**
+- Generate multiple query variations
+- Retrieve for all variations
+- Combine results
+
+**Contextual Compression**
+- Retrieve documents
+- Extract only relevant parts
+- Reduce context size
+
+**Parent Document Retrieval**
+- Index small chunks
+- Retrieve full parent documents
+- Best of both worlds
+
+**Ensemble Retrieval**
+- Combine semantic + keyword search
+- Weighted combination
+- Better recall
+
+**Reranking**
+- Initial retrieval
+- Rerank with cross-encoder
+- Better precision
+
+### What to Master
+- Choosing retrieval strategies
+- Combining multiple approaches
+- Evaluating retrieval quality
+- Optimizing for latency vs quality
+
+---
+
+## 13. Callbacks and Observability
+
+Understanding what your agents are doing.
+
+### What to Track
+- Token usage (cost)
+- Latency per step
+- Tool execution times
+- Error rates
+- Retrieval quality
+- User satisfaction
+
+### Integration Points
+- LangSmith for tracing
+- Custom logging
+- Metrics systems
+- Alerting
+
+### What to Master
+- Designing callback handlers
+- Async callbacks for non-blocking
+- Aggregating metrics
+- Setting up alerts
+
+---
+
+## 14. Dynamic Tool Generation
+
+Tools that create themselves.
+
+### Key Patterns
+
+**API-Based Tools**
+- Generate tools from OpenAPI specs
+- Database schema to tools
+- Dynamic API discovery
+
+**Dynamic Tool Selection**
+- Too many tools → select dynamically
+- Semantic matching to query
+- Limit active tools
+
+**Tool Composition**
+- Combine tools into workflows
+- Meta-tools that orchestrate
+- Adaptive tool creation
+
+### What to Master
+- API spec parsing
+- Dynamic function generation
+- Tool relevance scoring
+- Managing tool explosion
+
+---
+
+## 15. Complex Chain Patterns
+
+Advanced chain compositions.
+
+### Key Patterns
+
+**Map-Reduce**
+- Process chunks in parallel (map)
+- Combine results (reduce)
+- Good for large documents
+
+**Refine**
+- Iteratively refine answer
+- Each document improves result
+- Good for synthesis
+
+**Branching**
+- Conditional paths
+- Multiple parallel branches
+- Merge results
+
+### What to Master
+- Choosing the right pattern
+- Handling large inputs
+- Parallel execution
+- Result aggregation
+
+---
+
+## 16. LangGraph Advanced Patterns
+
+Deep LangGraph knowledge.
+
+### Key Patterns
+
+**Subgraphs**
+- Nested graphs for modularity
+- Reusable workflow components
+- Clean separation of concerns
+
+**Parallel Execution**
+- Fan out to multiple nodes
+- Process in parallel
+- Fan in to merge
+
+**Time Travel**
+- Replay from any checkpoint
+- Debug by stepping through
+- Modify and replay
+
+**Conditional Cycles**
+- Loop until condition met
+- Self-improvement loops
+- Bounded iteration
+
+### What to Master
+- Graph design patterns
+- State serialization
+- Checkpoint management
+- Debugging complex graphs
+
+---
+
+## 17. Guardrails and Safety
+
+Keeping agents safe.
+
+### Key Patterns
+
+**Constitutional AI**
+- Self-critique
+- Revise harmful outputs
+- Principle-based filtering
+
+**Input Validation**
+- Check inputs before processing
+- Reject unsafe requests
+- Log suspicious activity
+
+**Output Filtering**
+- Check outputs before returning
+- Remove sensitive information
+- Ensure policy compliance
+
+**Rate Limiting**
+- Prevent abuse
+- Per-user limits
+- Anomaly detection
+
+### What to Master
+- Designing safety principles
+- Input/output validation
+- PII detection and removal
+- Audit logging
+
+---
+
+## 18. Advanced Prompting Patterns
+
+Sophisticated prompt engineering.
+
+### Key Patterns
+
+**Few-Shot Learning**
+- Include examples in prompt
+- Dynamic example selection
+- Semantic similarity for selection
+
+**Chain of Thought**
+- Step-by-step reasoning
+- Show work before answer
+- Better for complex tasks
+
+**Self-Consistency**
+- Generate multiple answers
+- Vote on best
+- Higher reliability
+
+**Role Prompting**
+- Assign specific roles
+- Expert personas
+- Behavior shaping
+
+### What to Master
+- Example selection strategies
+- Prompt templates
+- Dynamic prompt construction
+- Prompt optimization
+
+---
+
+## 19. Testing Patterns
+
+Ensuring quality.
+
+### Key Patterns
+
+**Unit Testing**
+- Test individual components
+- Mock LLM responses
+- Fast feedback
+
+**Integration Testing**
+- Test full chains
+- Real LLM calls
+- End-to-end verification
+
+**Regression Testing**
+- Maintain golden dataset
+- Detect quality drops
+- Continuous monitoring
+
+**Load Testing**
+- Test under load
+- Find bottlenecks
+- Capacity planning
+
+### What to Master
+- Mocking LLM calls
+- Test dataset curation
+- Evaluation metrics
+- CI/CD integration
+
+---
+
+## 20. LangServe Deployment Nuances
+
+Production deployment details.
+
+### Key Patterns
+
+**Custom Endpoints**
+- Custom input/output schemas
+- Disable playground in production
+- Custom error handling
+
+**Authentication**
+- Middleware for auth
+- Token validation
+- Role-based access
+
+**Batch Endpoints**
+- Automatic batch support
+- Efficient processing
+- Queue management
+
+**Scaling**
+- Horizontal scaling
+- Load balancing
+- Connection pooling
+
+### What to Master
+- FastAPI middleware
+- Authentication patterns
+- Performance tuning
+- Monitoring and logging
+
+---
+
+## Key Nuances Summary
+
+| Area | Critical Nuance |
+|------|-----------------|
+| **LangGraph** | State must be serializable; use Pydantic |
+| **Streaming** | Use `astream_events` for fine control |
+| **Memory** | Token counting is crucial for long chats |
+| **RAG** | Chunk size dramatically affects retrieval quality |
+| **Tools** | Too many tools confuses the LLM (keep under 10-15) |
+| **Callbacks** | Use async callbacks for non-blocking |
+| **Caching** | Semantic cache > exact match cache |
+| **Fallbacks** | Order matters; try cheapest/fastest first |
+| **Evaluation** | LLM-as-judge is powerful but needs calibration |
+| **Multi-agent** | Communication overhead can dominate |
+
+---
+
+## Interview-Worthy Project Ideas
+
+1. **LangGraph Multi-Agent Research System**
+   - Supervisor coordinates researcher, writer, reviewer agents
+   - Human approval before publishing
+   - Self-correction loop
+
+2. **Self-Correcting RAG System**
+   - Hallucination detection
+   - Automatic re-retrieval
+   - Quality scoring
+
+3. **Production Chatbot**
+   - Memory across sessions
+   - Streaming with progress
+   - Fallback chains
+   - Cost tracking
+
+4. **Code Assistant**
+   - Generate code
+   - Run tests
+   - Fix failures
+   - Iterate until passing
+
+5. **Research Agent**
+   - Web search
+   - Document analysis
+   - Citation tracking
+   - Human-in-the-loop approval
+
+---
+
+## What Interviewers Look For
+
+| Question They Ask | What Impresses |
+|-------------------|----------------|
+| "How does it handle failures?" | Fallback chains, retries, graceful degradation |
+| "How do you ensure quality?" | Self-checking, evaluation, human-in-the-loop |
+| "How does it scale?" | Caching, batching, async, connection pooling |
+| "How do agents coordinate?" | LangGraph, state machines, message passing |
+| "How do you monitor it?" | LangSmith, custom callbacks, cost tracking |
+| "How do you test it?" | Unit tests, regression tests, evaluation suites |
+
+---
+
+## Learning Path
+
+1. **Start**: Basic chains and prompts
+2. **Add**: Tools and agents
+3. **Upgrade**: RAG with advanced retrieval
+4. **Advanced**: LangGraph for stateful workflows
+5. **Production**: Streaming, caching, monitoring
+6. **Scale**: Multi-agent, human-in-the-loop
+7. **Master**: Evaluation, optimization, safety
+
+---
+
+*Last Updated: February 2026*
+

my_practice/first_llm_call.ipynb

@@ -0,0 +1,276 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f25e9940",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from litellm import completion\n",
+    "\n",
+    "\n",
+    "result = completion(\n",
+    "    model = 'gpt-4o',\n",
+    "    messages = [{'role':'user', 'content' : 'Hello'}]\n",
+    "\n",
+    ")\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fba08f3a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Hello! How can I assist you today?'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result.choices[0].message.content"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c283cf21",
+   "metadata": {},
+   "source": [
+    "Building data models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4a41257",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Union, Literal\n",
+    "from dataclasses import dataclass, field\n",
+    "from pydantic import BaseModel, Field, List, Dict, Any, Optional, BaseTool\n",
+    "import uuid\n",
+    "from datetime import datetime\n",
+    "import json\n",
+    "\n",
+    "## agent models\n",
+    "\n",
+    "class Message(BaseModel):\n",
+    "\n",
+    "    \"\"\"A text message in the conversation.\"\"\"\n",
+    "    type: Literal[\"message\"] = \"message\"\n",
+    "    role: Literal[\"system\", \"user\", \"assistant\"]\n",
+    "    content: str\n",
+    "\n",
+    "class ToolCall(BaseModel): \n",
+    "    \"\"\"LLM's request to execute a tool.\"\"\"\n",
+    "    type: Literal[\"tool_call\"] = \"tool_call\"\n",
+    "    tool_call_id: str\n",
+    "    name: str\n",
+    "    arguments: dict\n",
+    "    \n",
+    "\n",
+    "class ToolResult(BaseModel):\n",
+    "    \"\"\"Result from tool execution.\"\"\"\n",
+    "    type: Literal[\"tool_result\"] = \"tool_result\"\n",
+    "    tool_call_id: str\n",
+    "    name: str\n",
+    "    status: Literal[\"success\", \"error\"]\n",
+    "    content: list\n",
+    "\n",
+    "class ToolConfirmation(BaseModel): ## this is temperory so not in union (user to agent)\n",
+    "    \"\"\"User's decision on a pending tool call.\"\"\"\n",
+    "    tool_call_id: str\n",
+    "    approved: bool\n",
+    "    modified_arguments: dict | None = None\n",
+    "    reason: str | None = None  # Reason for rejection (if not approved)\n",
+    "\n",
+    "class PendingToolCall(BaseModel): ## this is temperory so not in union(agent to user)\n",
+    "    \"\"\"A tool call awaiting user confirmation.\"\"\"\n",
+    "    \n",
+    "    tool_call: ToolCall\n",
+    "    confirmation_message: str\n",
+    "\n",
+    "## every request returns with these things so union all of them\n",
+    "ContentItem = Union[Message, ToolCall, ToolResult, ToolConfirmation] ## keep adding if there is more\n",
+    "\n",
+    "class Event(BaseModel):\n",
+    "    \"\"\"A recorded occurrence during agent execution.\"\"\"\n",
+    "    id: str = Field(default_factory=lambda: str(uuid.uuid4()))\n",
+    "    execution_id: str\n",
+    "    timestamp: float = Field(default_factory=lambda: datetime.now().timestamp())\n",
+    "    author: str  # \"user\" or agent name\n",
+    "    content: List[ContentItem] = Field(default_factory=list)\n",
+    "\n",
+    "@dataclass\n",
+    "class ExecutionContext: ## there will be frequent modifications to this, so not basemodel\n",
+    "    \"\"\"Central storage for all execution state.\"\"\"\n",
+    "    \n",
+    "    execution_id: str = field(default_factory=lambda: str(uuid.uuid4()))\n",
+    "    events: List[Event] = field(default_factory=list)\n",
+    "    current_step: int = 0\n",
+    "    state: Dict[str, Any] = field(default_factory=dict)\n",
+    "    final_result: Optional[str | BaseModel] = None\n",
+    "    session_id: Optional[str] = None  # Link to session for persistence\n",
+    "\n",
+    "\n",
+    "\n",
+    "### lets do LLM models\n",
+    "\n",
+    "class LlmRequest(BaseModel):\n",
+    "    \"\"\"Request object for LLM calls.\"\"\"\n",
+    "    instructions: List[str] = Field(default_factory=list)\n",
+    "    contents: List[ContentItem] = Field(default_factory=list)\n",
+    "    tools: List[BaseTool] = Field(default_factory=list)\n",
+    "    tool_choice: Optional[str] = 'auto'\n",
+    "\n",
+    "class LlmResponse(BaseModel):\n",
+    "    \"\"\"Response object from LLM calls.\"\"\"\n",
+    "    content: List[ContentItem] = Field(default_factory=list)\n",
+    "    error_message: Optional[str] = None\n",
+    "    usage_metadata: Dict[str, Any] = Field(default_factory=dict)\n",
+    "\n",
+    "class LlmClient(BaseModel):\n",
+    "    def _parse_response(self, response) -> LlmResponse:\n",
+    "        \"\"\"Convert API response to LlmResponse.\"\"\"\n",
+    "        choice = response.choices[0]\n",
+    "        content_items = []\n",
+    "        \n",
+    "        # Parse message content\n",
+    "        if choice.message.content:\n",
+    "            content_items.append(Message(\n",
+    "                role=\"assistant\",\n",
+    "                content=choice.message.content\n",
+    "            ))\n",
+    "\n",
+    "        # Parse tool calls\n",
+    "        if choice.message.tool_calls:\n",
+    "            for tc in choice.message.tool_calls:\n",
+    "                content_items.append(ToolCall(\n",
+    "                    tool_call_id=tc.id,\n",
+    "                    name=tc.function.name,\n",
+    "                    arguments=json.loads(tc.function.arguments)\n",
+    "                ))\n",
+    "        \n",
+    "        return LlmResponse(\n",
+    "            content=content_items,\n",
+    "            usage_metadata={\n",
+    "                \"input_tokens\": response.usage.prompt_tokens,\n",
+    "                \"output_tokens\": response.usage.completion_tokens,\n",
+    "            }\n",
+    "        )   ## this is internal method to parse toolcalls, reasoning, message content\n",
+    "        \n",
+    "\n",
+    "def build_messages(request: LlmRequest) -> List[dict]: ## will be reused everywhere\n",
+    "    \"\"\"Convert LlmRequest to API message format.\"\"\"\n",
+    "    messages = []\n",
+    "    \n",
+    "    # Add system instructions\n",
+    "    for instruction in request.instructions:\n",
+    "        messages.append({\"role\": \"system\", \"content\": instruction})\n",
+    "    \n",
+    "    # Convert content items\n",
+    "    for item in request.contents:\n",
+    "        if isinstance(item, Message):\n",
+    "            messages.append({\"role\": item.role, \"content\": item.content})\n",
+    "            \n",
+    "        elif isinstance(item, ToolCall):\n",
+    "            tool_call_dict = {\n",
+    "                \"id\": item.tool_call_id,\n",
+    "                \"type\": \"function\",\n",
+    "                \"function\": {\n",
+    "                    \"name\": item.name,\n",
+    "                    \"arguments\": json.dumps(item.arguments)\n",
+    "                }\n",
+    "            }\n",
+    "            # Append to previous assistant message if exists\n",
+    "            if messages and messages[-1][\"role\"] == \"assistant\":\n",
+    "                messages[-1].setdefault(\"tool_calls\", []).append(tool_call_dict)\n",
+    "            else:\n",
+    "                messages.append({\n",
+    "                    \"role\": \"assistant\",\n",
+    "                    \"content\": None,\n",
+    "                    \"tool_calls\": [tool_call_dict]\n",
+    "                })\n",
+    "                \n",
+    "        elif isinstance(item, ToolResult):\n",
+    "            messages.append({\n",
+    "                \"role\": \"tool\",\n",
+    "                \"tool_call_id\": item.tool_call_id,\n",
+    "                \"content\": str(item.content[0]) if item.content else \"\"\n",
+    "            })\n",
+    "    \n",
+    "    return messages\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4b6afba",
+   "metadata": {},
+   "source": [
+    "Building our Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d7d0140",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from typing import List, Optional\n",
+    "from .llm import LlmClient\n",
+    "from .models import ExecutionContext\n",
+    "\n",
+    "class Agent:\n",
+    "    \"\"\"Agent that can reason and use tools to solve tasks.\"\"\"\n",
+    "    \n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        model: LlmClient,\n",
+    "        tools: List[BaseTool] = None,\n",
+    "        instructions: str = \"\",\n",
+    "        max_steps: int = 5,\n",
+    "        name: str = \"agent\"\n",
+    "    ):\n",
+    "        self.model = model\n",
+    "        self.instructions = instructions\n",
+    "        self.max_steps = max_steps\n",
+    "        self.name = name\n",
+    "        self.tools = tools or []"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

my_practice/pydantic.ipynb

@@ -0,0 +1,255 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ff3b1200",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "msg1.role: user\n",
+      "msg2.role: assistant\n",
+      "msg3.role: system\n",
+      "\n",
+      "Validation error: 1 validation error for Message\n",
+      "role\n",
+      "  Input should be 'user', 'assistant' or 'system' [type=literal_error, input_value='admin', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/literal_error\n",
+      "\n",
+      "Missing field error: 1 validation error for Message\n",
+      "content\n",
+      "  Field required [type=missing, input_value={'role': 'user'}, input_type=dict]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/missing\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pydantic import BaseModel, ValidationError\n",
+    "from typing import Literal\n",
+    "\n",
+    "# Create a Message model like in your framework\n",
+    "class Message(BaseModel):\n",
+    "    role: Literal[\"user\", \"assistant\", \"system\"]\n",
+    "    content: str\n",
+    "\n",
+    "# Test 1: Valid messages\n",
+    "msg1 = Message(role=\"user\", content=\"Hello\")\n",
+    "msg2 = Message(role=\"assistant\", content=\"Hi there!\")\n",
+    "msg3 = Message(role=\"system\", content=\"You are helpful\")\n",
+    "\n",
+    "print(f\"msg1.role: {msg1.role}\")\n",
+    "print(f\"msg2.role: {msg2.role}\")\n",
+    "print(f\"msg3.role: {msg3.role}\")\n",
+    "\n",
+    "# Test 2: What happens with invalid role?\n",
+    "try:\n",
+    "    bad_msg = Message(role=\"admin\", content=\"test\")\n",
+    "except ValidationError as e:\n",
+    "    print(f\"\\nValidation error: {e}\")\n",
+    "\n",
+    "# Test 3: What happens with missing content?\n",
+    "try:\n",
+    "    incomplete = Message(role=\"user\")\n",
+    "except ValidationError as e:\n",
+    "    print(f\"\\nMissing field error: {e}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "811107f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\"role\":\"user\",\"content\":\"My Name is Akhil\",\"timestamp\":1769878310.697898}\n",
+      "{'role': 'user', 'content': 'My Name is Akhil', 'timestamp': 1769878310.697898}\n",
+      "user\n"
+     ]
+    }
+   ],
+   "source": [
+    "import datetime\n",
+    "from typing import Optional, List, Any, Dict\n",
+    "import uuid\n",
+    "from pydantic import Field\n",
+    "\n",
+    "class ChatMessage(BaseModel):\n",
+    "    role : Literal[\"user\", \"assistant\", \"system\"]\n",
+    "    content : str \n",
+    "    timestamp : float = Field(default_factory=lambda: datetime.datetime.now().timestamp())\n",
+    "\n",
+    "class ChatSession(BaseModel):\n",
+    "    session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))\n",
+    "    user_name : str\n",
+    "    messages : List[ChatMessage] = Field(default_factory=list)\n",
+    "    metadata : Dict[str, Any] = Field(default_factory=dict)\n",
+    "\n",
+    "    def add_message(self, role: Literal[\"user\", \"assistant\", \"system\"], content: str):\n",
+    "        self.messages.append(ChatMessage(role = role, content = content))\n",
+    "\n",
+    "\n",
+    "\n",
+    "chat = ChatMessage(role = \"user\", content = \"My Name is Akhil\")\n",
+    "\n",
+    "print(chat.model_dump_json())\n",
+    "print(chat.model_dump())\n",
+    "\n",
+    "msg2 = ChatMessage.model_validate({\"role\": \"user\", \"content\": \"hi\"})\n",
+    "print(msg2.role)\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "a38ac16e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting API 1...\n",
+      "Finished API 1\n",
+      "Starting API 2...\n",
+      "Finished API 2\n",
+      "Starting API 3...\n",
+      "Finished API 3\n",
+      "\n",
+      "Total time: 6.0 seconds\n",
+      "Results: Result from API 1, Result from API 2, Result from API 3\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def slow_api_call(name: str) -> str:\n",
+    "    \"\"\"Simulate a slow API call (like calling OpenAI)\"\"\"\n",
+    "    print(f\"Starting {name}...\")\n",
+    "    time.sleep(2)  # Blocks for 2 seconds\n",
+    "    print(f\"Finished {name}\")\n",
+    "    return f\"Result from {name}\"\n",
+    "\n",
+    "# Sequential calls - takes 6 seconds total\n",
+    "start = time.time()\n",
+    "\n",
+    "result1 = slow_api_call(\"API 1\")\n",
+    "result2 = slow_api_call(\"API 2\")\n",
+    "result3 = slow_api_call(\"API 3\")\n",
+    "\n",
+    "print(f\"\\nTotal time: {time.time() - start:.1f} seconds\")\n",
+    "print(f\"Results: {result1}, {result2}, {result3}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "afc59f41",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting API 1...\n",
+      "Starting API 2...\n",
+      "Starting API 3...\n",
+      "Finished API 1\n",
+      "Finished API 2\n",
+      "Finished API 3\n",
+      "\n",
+      "Total time: 2.0 seconds\n",
+      "Results: ['Result from API 1', 'Result from API 2', 'Result from API 3'], Result from API 2, Result from API 3\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import asyncio\n",
+    "\n",
+    "async def slow_api_call(name: str) -> str:\n",
+    "    \"\"\"Simulate a slow API call (like calling OpenAI)\"\"\"\n",
+    "    print(f\"Starting {name}...\")\n",
+    "    await asyncio.sleep(2)  # Blocks for 2 seconds\n",
+    "    print(f\"Finished {name}\")\n",
+    "    return f\"Result from {name}\"\n",
+    "\n",
+    "# Sequential calls - takes 6 seconds total\n",
+    "start = time.time()\n",
+    "\n",
+    "result1 = await asyncio.gather(\n",
+    "    slow_api_call(\"API 1\"),\n",
+    "slow_api_call(\"API 2\"),\n",
+    "slow_api_call(\"API 3\")\n",
+    ")\n",
+    "\n",
+    "print(f\"\\nTotal time: {time.time() - start:.1f} seconds\")\n",
+    "print(f\"Results: {result1}, {result2}, {result3}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "144c73f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['hi', 'hi', 'hi']\n"
+     ]
+    }
+   ],
+   "source": [
+    "async def fetch_weather(city: str) -> str:\n",
+    "    await asyncio.sleep(2)\n",
+    "    return \"hi\"\n",
+    "\n",
+    "async def fetch_news(news: str) -> str:\n",
+    "    await asyncio.sleep(1.5)\n",
+    "    return \"hi\"\n",
+    "\n",
+    "async def fetch_stock(symbool: str) -> str:\n",
+    "    await asyncio.sleep(1)\n",
+    "    return \"hi\"\n",
+    "\n",
+    "\n",
+    "results = await asyncio.gather(\n",
+    "         fetch_weather(\"hyd\"), fetch_news(\"hyd\"), fetch_stock(\"hyd\")\n",
+    "    )\n",
+    "print(results)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}