AnveshAI Edge V2

A fully offline, hybrid AI tutor for JEE Advanced — Physics, Chemistry, and Mathematics.

AnveshAI Edge is a terminal-based AI assistant designed to run entirely on-device (CPU only). It combines dedicated deterministic engines for Physics, Chemistry, and symbolic Mathematics with a local knowledge base and a compact 1.5B-parameter language model into a unified hierarchical pipeline. A chain-of-thought reasoning engine decomposes every problem before the LLM is invoked, significantly reducing hallucinations for supported deterministic problems and improving answer quality.

---

Table of Contents

1. Links
2. Architecture Overview
3. Components
4. JEE Advanced Domain Coverage
5. Question Bank
6. Advanced Math Engine
7. Reasoning Engine
8. Getting Started
9. Usage Examples
10. Commands
11. Design Principles
12. Current Limitations
13. File Structure
14. Technical Details

---

Links

• GitHub: Click Here!
• HuggingFace Spaces: Click Here!
• Zenodo: Coming Soon!

---

Why AnveshAI Edge?

• Works fully offline — no internet required after the one-time model download
• Gives step-by-step JEE Advanced-style solutions
• Uses far less compute than cloud AI tools — hybrid deterministic solving avoids sending every query through a large model, reducing compute cost significantly for supported problem types
• Designed for students on low-resource hardware

---

Benchmark Snapshot (V2)

---

Architecture Overview

AnveshAI Edge uses a hierarchical fallback pipeline with reasoning at every non-trivial stage:

User Input
    │
    ├── [/command]      ──► System Handler (instant)
    │
    ├── [arithmetic]    ──► Math Engine (AST safe-eval, instant)
    │
    ├── [physics]       ──► Reasoning Engine: analyze()
    │                          │  (problem type, strategy selection)
    │                          ▼
    │                       Physics Engine (formula solver)
    │                          │  EXACT answer computed
    │                          ▼
    │                       Reasoning Engine: build_math_prompt()
    │                          │  (CoT plan embedded in LLM prompt)
    │                          ▼
    │                       LLM (Qwen2.5-1.5B) → Step-by-step explanation
    │
    ├── [chemistry]     ──► Reasoning Engine: analyze()
    │                          ▼
    │                       Chemistry Engine (stoichiometry, equilibrium, kinetics…)
    │                          ▼
    │                       LLM with CoT context → User
    │
    ├── [advanced math] ──► Reasoning Engine: analyze()
    │                          ▼
    │                       Advanced Math Engine (SymPy — exact symbolic answer)
    │                          ▼
    │                       LLM with CoT context → User
    │
    ├── [knowledge]     ──► Knowledge Engine (local KB)
    │                          ├── match found → User
    │                          └── no match → LLM with CoT context → User
    │
    ├── [logic]         ──► Inference Engine (propositional logic)
    │                          └── LLM with CoT context → User
    │
    └── [conversation]  ──► Conversation Engine (pattern rules)
                               ├── matched → User
                               └── no match → LLM with CoT context → User

Key Design Principle

Correctness-first: For all deterministic problems (math, physics, chemistry), the domain engine computes the exact answer before the LLM is called. The LLM's only task is to explain the working — it cannot invent a wrong answer.

---

Components

---

JEE Advanced Domain Coverage

AnveshAI Edge currently supports core JEE Advanced topics, with ongoing solver expansion.

Physics Topics Handled

Chemistry Topics Handled

Mathematics Topics Handled

---

Question Bank

AnveshAI Edge includes 3,000 tagged benchmark questions (datasheet.csv) spanning all three subjects.

Dataset Format (datasheet.csv)

id, question, subject, topic, expected_intent, expected_problem_type

Each row contains a unique question ID, the full question text, subject, topic tag, the expected intent label (used by the router), and the expected problem type (used by the reasoning engine). This dataset is used by benchmark.py to evaluate end-to-end routing and classification accuracy.

Running the Benchmark

python benchmark.py

Outputs report.csv with per-question results and a summary block including overall accuracy, per-subject breakdown, and weak-topic identification.

---

Advanced Math Engine

The engine supports 31+ symbolic mathematics operations across 11 categories:

Calculus

Algebra & Equations

Differential Equations

Series & Transforms

Linear Algebra

Number Theory

Statistics

Combinatorics

Summations & Products

Complex Numbers

---

Reasoning Engine

The ReasoningEngine adds structured chain-of-thought reasoning at every stage.

Reasoning Pipeline (4 Stages)

Stage 1 — Problem Analysis

• Detects domain (15+ domains: calculus, linear algebra, coordinate_geometry, 3d_geometry, trigonometry, statistics, physics, chemistry, computer_science, …)
• Classifies problem type (64 problem types via priority-ordered regex)
• Identifies sub-questions implicit in the problem

Stage 2 — Strategy Selection

• Chooses the optimal solution method (u-substitution, L'Hôpital, ICE table, Kp-Kc relation, parallel axis theorem, …)
• Decomposes the problem into an ordered list of numbered reasoning steps

Stage 3 — Verification & Confidence

• Assigns confidence: HIGH (symbolic/deterministic answer available), MEDIUM, or LOW
• Detects warnings: missing bounds, undetected variables, potential singularities

Stage 4 — Prompt Engineering

• Builds a structured LLM prompt that embeds the full reasoning plan
• For math/physics/chemistry: forces the LLM to follow exact numbered steps toward the verified answer
• For knowledge: guides the LLM through the identified sub-questions in order

ReasoningPlan Data Structure

@dataclass
class ReasoningPlan:
    problem_type:    str        # e.g. "conic_parabola", "chemical_kinetics"
    domain:          str        # e.g. "coordinate_geometry", "chemistry"
    sub_problems:    list[str]  # ordered reasoning steps
    strategy:        str        # solution method description
    expected_form:   str        # what the answer should look like
    assumptions:     list[str]  # stated assumptions
    confidence:      str        # HIGH / MEDIUM / LOW
    warnings:        list[str]  # potential issues flagged

Problem Types Covered (64 types across 15+ domains)

Why Chain-of-Thought Matters for a Small LLM

The Qwen2.5-1.5B model has 1.5 billion parameters. Without structured guidance it can still:

• Skip algebraic steps
• Confuse method with result on multi-step problems
• Apply correct techniques incorrectly

By embedding a detailed reasoning plan in every prompt — and for deterministic problems, by providing the correct answer upfront — the model's role becomes that of a step-by-step explainer rather than an unsupervised solver. This dramatically improves output quality without requiring a larger model.

---

Getting Started

System Requirements

First run: The Qwen2.5-1.5B model (~1 GB) is downloaded automatically from HuggingFace and cached locally. Expect 5–15 minutes depending on your connection speed. Subsequent runs load from cache instantly.

Installation

pip install sympy llama-cpp-python colorama

Note for llama-cpp-python: This package compiles C++ code during installation. You may need:

• A C++ compiler (gcc / g++ on Linux, Xcode CLI tools on macOS)
• At least 2 GB of free RAM during the build
• If the build fails, try: pip install llama-cpp-python --no-cache-dir

Replit users: Use the AnveshAI Edge workflow — dependencies are pre-configured. RAM may be limited on free-tier instances; the model may load slowly or require a paid plan with higher memory.

Troubleshooting

Running

cd anveshai
python main.py
# try: "integrate x^2 sin(x)"

Or use the AnveshAI Edge workflow in the Replit environment.

---

Usage Examples

You › A spring of constant 200 N/m has a mass of 0.5 kg attached. Find the time period.

  Physics Engine → T = 2π√(m/k) = 2π√(0.5/200) = 0.314 s
  [Reasoning] domain=physics | type=shm_problem | strategy=SHM formula | confidence=HIGH

AnveshAI [Physics+CoT+LLM] › T ≈ 0.314 s
  Step 1: Identify the spring-mass system parameters: k = 200 N/m, m = 0.5 kg
  Step 2: Apply the SHM time period formula: T = 2π√(m/k)
  Step 3: Substitute: T = 2π√(0.5/200) = 2π × 0.05 = 0.314 s

You › Kc for N2 + 3H2 ⇌ 2NH3 is 0.5 at 400K. Find Kp.

  Chemistry Engine → Kp = Kc(RT)^Δn,  Δn = 2−4 = −2
  [Reasoning] domain=chemistry | type=chemical_equilibrium | confidence=HIGH

AnveshAI [Chem+CoT+LLM] › Kp = Kc × (RT)^(−2) ≈ 3.27 × 10⁻⁵
  Step 1: Write the balanced equation and count Δn = moles product gas − moles reactant gas
  Step 2: Δn = 2 − (1 + 3) = −2
  Step 3: Apply Kp = Kc(RT)^Δn = 0.5 × (0.0821 × 400)^(−2)

You › Find the equation of tangent to parabola y²=8x at point (2,4).

  SymPy → Tangent computed
  [Reasoning] domain=coordinate_geometry | type=conic_parabola | confidence=HIGH

AnveshAI [AdvMath+CoT+LLM] › y = x + 2
  Step 1: Identify standard form y²=4ax, so a = 2
  Step 2: Slope of tangent at (x₁, y₁): m = 2a/y₁ = 4/4 = 1
  Step 3: Tangent equation: yy₁ = 2a(x + x₁) → 4y = 4(x + 2) → y = x + 2

You › integrate x^2 sin(x)

  SymPy → ∫ (x**2*sin(x)) dx = -x**2*cos(x) + 2*x*sin(x) + 2*cos(x) + C
  [Reasoning] domain=calculus | strategy=Apply integration by parts (IBP) | confidence=HIGH

AnveshAI [AdvMath+CoT+LLM] › -x**2*cos(x) + 2*x*sin(x) + 2*cos(x) + C
  Step 1: Use Integration by Parts twice: u = x², dv = sin(x)dx
  …

---

Commands

---

Design Principles

1. Correctness-first for deterministic problems — The domain engine (SymPy / Physics / Chemistry) always runs before the LLM. The LLM explains, it does not compute.

2. Offline-first — All computation runs locally. No API keys, no internet connection required after the one-time model download (~1 GB).

3. JEE Advanced focus — System prompts, strategy libraries, and reasoning steps are tuned for JEE Advanced level. Domain scoring prioritises correct sub-domain classification (SHM vs rotational, equilibrium vs kinetics, conics vs 3D).

4. Transparency — The system prints its internal reasoning trace to the console (engine used, reasoning plan summary, confidence, warnings).

5. Graceful degradation — Every engine has a fallback: SymPy failures fall back to CoT-guided LLM, KB misses fall back to reasoning-guided LLM.

6. Safety — Arithmetic uses AST-based safe-eval (no eval()). Matrix parsing uses a validated bracket pattern before eval(). The LLM prompt explicitly forbids inventing a different answer.

7. Modularity — Every engine is independent and communicates through simple return types. Adding a new math operation requires only a new handler function and a keyword entry.

---

Current Limitations

• Some advanced Physics and Chemistry formula handlers are still being added; solver gaps account for all current benchmark failures
• Open-ended conceptual explanations depend on the 1.5B LLM and may vary in depth or phrasing
• CPU inference speed depends on hardware — responses may take several seconds on lower-end machines
• The model requires at least ~3 GB of free RAM to load comfortably

---

File Structure

anveshai/
├── main.py                 # REPL loop, orchestration, response composer
├── router.py               # Rule-based intent classifier (8 intents)
├── math_engine.py          # Safe AST arithmetic evaluator
├── advanced_math_engine.py # SymPy symbolic engine (31+ operations)
├── physics_engine.py       # JEE Advanced Physics formula solver
├── chemistry_engine.py     # JEE Advanced Chemistry solver
├── reasoning_engine.py     # Structured reasoning planner (64 problem types)
├── llm_engine.py           # Qwen2.5-1.5B-Instruct GGUF loader, JEE tuned prompts
├── inference_engine.py     # Propositional logic / deductive reasoning
├── knowledge_engine.py     # Local KB lookup (knowledge.txt)
├── conversation_engine.py  # Pattern-response engine (conversation.txt)
├── memory.py               # SQLite conversation history
├── knowledge.txt           # Local knowledge base paragraphs
├── conversation.txt        # PATTERN|||RESPONSE rule pairs
└── anveshai_memory.db      # Auto-created SQLite DB (gitignored)

---

Technical Details

Model

• Name: Qwen2.5-1.5B-Instruct
• Format: GGUF (Q4_K_M quantisation, ~1 GB)
• Runtime: llama-cpp-python (CPU-only via llama.cpp)
• Context window: 16,384 tokens
• Parameters: 1.5B (3× the original 0.5B for noticeably better reasoning)
• Threads: 4 CPU threads
• System prompt: JEE Advanced tutor — exam-focused, notation-correct, concise

Symbolic Engine

• Library: SymPy 1.x
• Parsing: sympy.parsing.sympy_parser with implicit multiplication and XOR-to-power transforms
• Supported variables: x, y, z, t, n, k, a, b, c, m, n, p, q, r, s
• Special constants: π, e, i (imaginary), ∞

Chain-of-Thought Reasoning

• Domain detection: 15+ domain categories with keyword matching
• Problem type classification: 64 problem types via priority-ordered regex
• Strategy library: Pre-defined strategies for 64 problem types
• Decomposition: Problem-specific step generators for 50+ operation types
• Confidence levels: HIGH (deterministic result available) / MEDIUM / LOW
• JEE-specific types: SHM, rotational mechanics, modern physics, electrostatics, electromagnetism, chemical equilibrium, chemical kinetics, solid state, colligative properties, conic sections, 3D geometry, Bayes probability, binomial theorem, sequences/series, trig equations, inverse trig, maxima/minima

Response Labels

Intent Routing

Benchmark routing accuracy on full 3,000-question dataset: 100%