Skip to content

Conversation

@gwho
Copy link

@gwho gwho commented Dec 23, 2025

🤖 Context-Aware Customer Support Agent with Langbase

Overview

This PR adds a comprehensive educational project that teaches RAG (Retrieval Augmented Generation) from first principles using Langbase primitives. Built with a bottom-up learning approach - no black boxes, just explicit SDK calls and well-commented code.

🎯 What This Adds

A complete learning project that builds an AI support agent step-by-step:

📚 Core Learning Scripts (4 Progressive Steps)

  1. 1-memory-creation.ts - Memory Primitive (Data Layer)

    • Demonstrates parsing, chunking, and embedding
    • Uploads FAQ knowledge base to vector database
    • Explains how semantic search works
  2. 2-retrieval-test.ts - Retrieval Testing (Logic Layer)

    • Tests semantic search WITHOUT the LLM
    • Shows raw chunks and similarity scores
    • Teaches top_k parameter tuning
  3. 3-pipe-creation.ts - Pipe Primitive (Cognition Layer)

    • Creates AI agent with system prompt
    • Configures model, temperature, and memory attachment
    • Demonstrates the full cognition layer
  4. main.ts - Full Orchestration

    • Production-ready RAG pipeline
    • Interactive and single-query modes
    • Debug mode to see retrieval details

🧪 Mini-Projects (4 Hands-On Experiments)

  1. Personality Swap - Test 5 different personas (pirate, sarcastic, Shakespeare, etc.)
  2. Knowledge Injection - Add new documents without code changes (Quantum Spaghetti recipe!)
  3. Accuracy Tuner - Optimize top_k retrieval parameter (1 vs 20 chunks)
  4. Multi-Format Challenge - Test CSV, structured text, and other formats

📖 Documentation

  • README.md - Comprehensive learning guide with architecture diagrams
  • QUICKSTART.md - 5-minute setup guide
  • PROJECT-SUMMARY.md - Learning outcomes and recommended path

🗄️ Sample Data

  • FAQ.txt - 5,000+ word customer support knowledge base covering 30+ topics

🎓 Learning Philosophy

This project teaches:

  • WHY each component exists (not just how to use it)
  • HOW components work together (explicit SDK calls)
  • WHEN to use different configurations (trade-offs explained)
  • WHERE things can go wrong (debugging guidance)

🏗️ Architecture

claude and others added 8 commits December 20, 2025 10:04
Implemented a complete educational Rubik's Cube solver in Python with:

Core Features:
- 54-sticker cube representation (URFDLB order)
- All basic moves (U, R, F, D, L, B) with inverses and double turns
- Two solving approaches:
  * SimpleSolver: BFS-based optimal solver for short scrambles
  * BeginnerSolver: Layer-by-layer method (experimental)

Code Organization:
- src/cube_state.py: CubeState class with 54-sticker model
- src/moves.py: Move execution and algorithms
- src/simple_solver.py: Breadth-first search solver
- src/solver.py: Layer-by-layer solver
- src/utils.py: Helper functions for piece finding
- tests/: Comprehensive unit tests

Educational Tools:
- demo.py: Interactive CLI with scramble and solve
- Comprehensive README with examples and learning resources
- Clear comments and docstrings throughout
- Focus on readability over performance

The implementation prioritizes:
- Clarity and educational value
- Correctness and testability
- Modular, beginner-friendly code
- No external dependencies (pure Python)

Perfect for learning about state representation, search algorithms,
and algorithmic problem-solving.
CRITICAL BUG FIX:
- Fixed apply_R_prime reversal logic (line 209 in src/moves.py)
- Bug caused R' R to not return to identity state
- This made all solvers unusable as moves corrupted cube state

NEW FEATURES:
- Added comprehensive move correctness test suite (tests/test_move_correctness.py)
  * Identity tests (M^4 = identity, M M' = identity)
  * Bijection/permutation validation
  * Color invariant tests
  * Random scramble/inverse verification (20 test cases)
  * Fixed sexy move period (6 -> 105)

- Added cube inspection/debugging tools (src/inspect.py)
  * find_edge/find_corner with PieceNotFoundError exceptions
  * edge_solved/corner_solved verification
  * edge_oriented orientation checking
  * cube_to_pretty_string with highlighting
  * count_solved_pieces progress tracking
  * Max iteration guards prevent infinite loops

DOCUMENTATION:
- Added DEBUGGING_NOTES.md with detailed analysis
  * How the bug was found (binary search through failing tests)
  * Impact analysis
  * Verification status
  * Known remaining issues
  * Recommendations for future work

TESTING STATUS:
- All basic move tests pass (U/U', R/R', F/F', D/D', L/L', B/B')
- Color invariants preserved
- 16 random scramble tests still failing (needs investigation)
- BeginnerSolver still has logic issues (separate task)

This fix was found through systematic testing with uniquely marked
cube stickers, allowing precise tracing of where pieces moved.
This commit adds extensive educational documentation explaining the
bug fixes, design decisions, and programming lessons learned.

NEW FILE: GUIDE_FOR_BEGINNERS.md (9,000+ words)
===========================================
A complete beginner-friendly guide covering:

1. OVERVIEW: What Was Broken and Why
   - The R' bug's impact (made solver completely unusable)
   - Root cause analysis (one character wrong)
   - Solution approach (fix + safeguards)

2. THE CRITICAL BUG: R' Move
   - Detailed explanation of what R and R' moves do
   - Mathematical property: R followed by R' = identity
   - The buggy code with line-by-line trace showing the error
   - Why the confusion happened (copied pattern from R without adapting)
   - Impact analysis (cascading effects on solver)

3. NEW TEST SUITE: Catching Bugs Early
   - 10 different test types with explanations
   - Test 1: Move Identity (M^4 = identity)
   - Test 2: Move Inverse (M M' = identity) ← THE test that caught the bug
   - Test 3: Bijection Test (valid permutations)
   - Test 4: Color Invariants
   - Test 5: Random Scramble and Inverse ← Most important end-to-end test
   - Test 6: Commutativity
   - Each test includes "For beginners" real-world analogies
   - Example: Move inverse like walking forward then backward
   - Shows how test found the bug through binary search

4. INSPECTION TOOLS: Debugging Made Easy
   - Explains "silent failure" anti-pattern
   - Tool 1: Exception with Context (vs returning None)
   - Tool 2: Structured Piece References (dataclass vs tuple)
   - Tool 3: Safe Piece Finding (max_iterations guard)
   - Tool 4: State Verification (edge_solved, corner_solved)
   - Tool 5: Pretty Printing with Highlighting
   - Tool 6: Progress Tracking
   - Real-world analogies for each concept

5. HOW THESE CHANGES WORK TOGETHER
   - Diagram showing test → moves → inspection → solver flow
   - Multi-layer safety net (tests, exceptions, verification)
   - Example: How bugs are caught at each layer

6. KEY PROGRAMMING LESSONS
   - Lesson 1: One Bug Can Break Everything
   - Lesson 2: Silent Failures Are Deadly
   - Lesson 3: Tests Are Documentation
   - Lesson 4: Debug Information Is Gold
   - Lesson 5: Structure Prevents Bugs
   - Each with real-world analogies (car brakes, dashboards, etc.)

7. SUMMARY: Before vs After comparison table

ENHANCED CODE COMMENTS:
=======================

src/moves.py (apply_R_prime function):
- Added 40+ lines of explanatory comments
- Documents the mathematical property that must hold
- Explains the cycle direction (counter-clockwise)
- Details WHY specific positions are used
- Step-by-step explanation of the bug:
  * What the buggy code did (double reversal)
  * Why it was wrong (corrupted D face sticker order)
  * What the fix does (correct direct mapping)
- Includes "Bug History" section in docstring
- Cross-references DEBUGGING_NOTES.md

src/inspect.py (module and key functions):
- Module-level docstring explains design philosophy:
  * No silent failures
  * Bounded iterations
  * Structured data
  * Helpful errors
- PieceNotFoundError class:
  * Explains why exceptions are better than None
  * Shows example usage
  * Documents what information is included
- EdgeRef/CornerRef dataclasses:
  * Explains why dataclass is better than tuple
  * Shows before/after comparison
  * Lists 5 specific benefits
  * Documents each field's purpose
- find_edge function:
  * Explains max_iterations guard in detail
  * Shows scenarios with/without the guard
  * Documents WHY 24 (2× number of edges)
  * Comments on each step of the search
  * Explains possible causes when piece not found

EDUCATIONAL VALUE:
==================
This documentation teaches:
- How to debug systematically (binary search, tracing)
- Why tests are essential (catch bugs in minutes vs weeks)
- Good error handling practices (exceptions with context)
- Data structure design (structured types vs tuples)
- Defensive programming (guards, bounds checking)
- The value of documentation (helps future self)

All explanations use:
- Real-world analogies (cars, GPS, dashboards, light switches)
- Before/after comparisons
- Concrete examples with output
- Clear "For beginners" sections
- Beginner-friendly language (no jargon without explanation)

TARGET AUDIENCE:
================
- Programming beginners learning Python
- Students learning algorithmic thinking
- Anyone wanting to understand the cube solver
- Future contributors to the project

The guide transforms complex debugging and design decisions into
accessible lessons that teach transferable programming skills.
Adds PROJECT_STRUCTURE.md - a comprehensive architectural overview of the
entire project covering:

- Quick navigation guide to all documentation
- Detailed explanation of each module (cube_state, moves, inspect, solvers)
- File structure with status indicators (✅ working, ⚠️ needs work)
- How the system works together (flow diagrams)
- Multi-layer safety net (tests → inspection → verification)
- Development workflow (running tests, using demo, debugging)
- Key achievements and what needs work
- Beginner guidance (where to start based on goals)
- Design philosophy (correctness > performance, clarity > cleverness)
- Success metrics (before/after comparison table)
- Future roadmap (prioritized)

This document serves as the entry point for understanding the entire
codebase architecture and navigating to more detailed documentation.

Target audience: Anyone trying to understand how the project is organized
and where to find specific information.
Implemented a comprehensive educational project that teaches RAG (Retrieval Augmented Generation) from first principles using Langbase primitives.

## Project Structure
- Bottom-up learning approach: Memory → Retrieval → Pipe → Orchestration
- 4 progressive scripts teaching each primitive component
- 4 mini-projects for hands-on tinkering and experimentation
- Comprehensive documentation with learning guides

## Core Components
1. **Memory Creation** (1-memory-creation.ts)
   - Demonstrates parsing, chunking, and embedding pipeline
   - Uploads FAQ.txt knowledge base
   - Explains vector database indexing

2. **Retrieval Testing** (2-retrieval-test.ts)
   - Tests semantic search before LLM integration
   - Shows chunk retrieval and similarity scoring
   - Explains top_k parameter tuning

3. **Pipe Creation** (3-pipe-creation.ts)
   - Creates AI agent with system prompt
   - Configures model, temperature, and memory attachment
   - Demonstrates the cognition layer

4. **Main Orchestration** (main.ts)
   - Full RAG pipeline integration
   - Interactive and single-query modes
   - Production-ready architecture with debug mode

## Mini-Projects
1. **Personality Swap**: Test different system prompts (pirate, sarcastic, etc.)
2. **Knowledge Injection**: Add new documents without code changes
3. **Accuracy Tuner**: Optimize top_k retrieval parameter
4. **Multi-Format Challenge**: Test CSV, PDF, and other file formats

## Features
- Well-commented code explaining every concept
- No "magic" - uses explicit SDK calls
- Modular design for easy customization
- Comprehensive error handling and troubleshooting
- QUICKSTART.md for 5-minute setup
- Detailed README with learning path

## Tech Stack
- TypeScript + Node.js
- Langbase SDK for RAG primitives
- Environment-based configuration
- Development tooling (tsx, TypeScript)

This project teaches AI agent development through hands-on building rather than using pre-made templates.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants