Update main.py

main.py

@@ -2,7 +2,6 @@ import os
 import asyncio
 import logging
 import json
-import re
 import torch
 import numpy as np
 import httpx
@@ -41,459 +40,1043 @@ logger = logging.getLogger("infinitygrm")
 
 
 # ============================================================
-# GLOBAL STATE
+# GLOBAL ENGINE STATE
 # ============================================================
 
 engine_state = {}
+
+# Temporary in-memory session storage
+# Replace with Redis later if needed.
 session_store = {}
 
 
 # ============================================================
-# REASONING SETTINGS
+# REASONING EXAMPLES
+#
+# These are intentionally concise.
+#
+# The model should learn:
+# - how to identify the problem type
+# - how to reject tempting wrong approaches
+# - how to identify useful state/invariants
+# - how to verify an answer
+# - how to reason about complexity
+#
+# You can expand this list to 200-500+ examples.
 # ============================================================
 
-REASONING_ENABLED = True
+REASONING_EXAMPLES = [
 
-# How many examples are placed into a difficult prompt.
-REASONING_EXAMPLES_PER_REQUEST = 3
+    {
+        "category": "algorithms",
+        "problem": """
+Given an array of integers that may contain negative numbers,
+find the longest contiguous subarray whose sum equals k.
+""",
+        "reasoning": """
+Key observation:
+Negative numbers make a normal sliding window unreliable because
+adding an element can decrease the sum and removing an element can
+increase it.
 
-# Keep examples reasonably small so prompts do not become huge.
-REASONING_MAX_EXAMPLE_CHARS = 2500
+Use prefix sums.
 
+If the current prefix sum is S, we need an earlier prefix sum S-k.
+Store the earliest index of every prefix sum because the earliest
+index gives the longest possible subarray.
+""",
+        "answer": """
+Use a hashmap of prefix sums.
 
-# ============================================================
-# REASONING EXAMPLES
-#
-# Add more examples to this list later.
-# These are in-context examples, NOT actual weight training.
-# ============================================================
+prefix = {0: -1}
+running_sum = 0
+best = 0
 
-REASONING_EXAMPLES = [
+For each index i:
+    running_sum += nums[i]
+
+    if running_sum - k exists:
+        best = max(best, i - prefix[running_sum - k])
+
+    store running_sum only if it has not been seen before.
+
+Time: O(n) average.
+Space: O(n).
+"""
+    },
 
     {
-        "category": "algorithm",
-        "question": """
-Write a Python function that finds the longest substring without
-repeating characters.
+        "category": "graphs",
+        "problem": """
+A directed graph has positive edge costs. You may use a discount
+exactly once, causing one chosen edge to cost floor(cost / 2).
+Find the minimum cost from s to t.
 """,
         "reasoning": """
-Use a sliding window. Keep a left pointer and scan the string with a
-right pointer. Store the most recent index of every character. When a
-duplicate occurs inside the current window, move the left pointer past
-the previous occurrence. Track the largest window length.
+The cost of traversing an edge depends on whether the discount has
+already been used.
+
+Therefore one distance per node is insufficient.
+
+Use two states:
+(node, unused)
+(node, used)
+
+From an unused state, an edge can either be taken normally or with
+the discount. From a used state, it must be taken normally.
+
+Run Dijkstra on this expanded state graph.
 """,
         "answer": """
-def longest_unique_substring(s):
-    last_seen = {}
-    left = 0
-    best = 0
+Dijkstra over 2*n states.
+
+unused -> unused with cost c
+unused -> used with cost c // 2
+used -> used with cost c
+
+Answer is the distance to t in the appropriate final state.
+
+Time: O((n+m) log n).
+Space: O(n+m).
+"""
+    },
+
+    {
+        "category": "algorithms",
+        "problem": """
+Determine whether a directed graph contains a cycle in O(V+E).
+""",
+        "reasoning": """
+A visited set alone is insufficient for directed-cycle detection.
 
-    for right, char in enumerate(s):
-        if char in last_seen and last_seen[char] >= left:
-            left = last_seen[char] + 1
+A node can be completely processed without forming a cycle, while
+another edge can point back to a node currently being explored.
 
-        last_seen[char] = right
-        best = max(best, right - left + 1)
+Use three states:
+0 = unvisited
+1 = currently exploring
+2 = completely processed
 
-    return best
+An edge to a state-1 node is a back edge and proves a cycle.
+""",
+        "answer": """
+Use DFS with three colors/states.
 
-Time complexity: O(n).
-Space complexity: O(k), where k is the number of distinct characters.
+Time: O(V+E).
+Space: O(V).
 """
     },
 
     {
-        "category": "algorithm",
-        "question": """
-Given an array of integers, find the length of the longest contiguous
-subarray whose sum is exactly k. The array can contain negative numbers.
+        "category": "data_structures",
+        "problem": """
+Find the first non-repeating character in a string.
 """,
         "reasoning": """
-A normal sliding window does not work because negative values make the
-sum non-monotonic.
+The answer depends on both frequency and original order.
 
-Use prefix sums. If the current prefix sum is P, we need an earlier
-prefix sum equal to P - k. Store the earliest index for each prefix sum.
-The earliest index gives the longest possible subarray.
+First count every character.
+Then scan the string again and return the first character whose
+frequency is one.
 """,
         "answer": """
-def longest_subarray_sum_k(nums, k):
-    first_seen = {0: -1}
-    prefix = 0
-    best = 0
+Use a frequency hashmap followed by a second scan.
 
-    for i, value in enumerate(nums):
-        prefix += value
-        needed = prefix - k
+Time: O(n).
+Space: O(k), where k is the number of distinct characters.
+"""
+    },
 
-        if needed in first_seen:
-            best = max(best, i - first_seen[needed])
+    {
+        "category": "algorithms",
+        "problem": """
+Given a sorted array, determine whether two numbers sum to target.
+""",
+        "reasoning": """
+Because the array is sorted, two pointers can eliminate many
+possibilities at once.
 
-        if prefix not in first_seen:
-            first_seen[prefix] = i
+If left + right is too small, increase left.
+If it is too large, decrease right.
+If equal, the target exists.
+""",
+        "answer": """
+Use two pointers.
 
-    return best
+Time: O(n).
+Space: O(1).
+"""
+    },
 
-Time: O(n) expected.
-Space: O(n).
+    {
+        "category": "algorithms",
+        "problem": """
+Find the shortest path in an unweighted graph.
+""",
+        "reasoning": """
+Every edge has equal cost.
+
+Therefore BFS explores nodes in increasing number of edges from
+the source. The first time a node is reached is its shortest
+distance from the source.
+""",
+        "answer": """
+Use BFS with a queue.
+
+Time: O(V+E).
+Space: O(V).
+"""
+    },
+
+    {
+        "category": "algorithms",
+        "problem": """
+Find the shortest path in a graph with positive weighted edges.
+""",
+        "reasoning": """
+BFS is not sufficient because edges have different costs.
+
+Since all edge weights are positive, Dijkstra's greedy selection
+of the currently cheapest unsettled node is valid.
+""",
+        "answer": """
+Use Dijkstra with a min-heap.
+
+Typical complexity:
+O((V+E) log V).
+"""
+    },
+
+    {
+        "category": "algorithms",
+        "problem": """
+A graph has only edge weights 0 and 1. Find shortest paths.
+""",
+        "reasoning": """
+Ordinary BFS treats every edge as having equal cost, which is wrong.
+
+Dijkstra works, but a deque can exploit the special weights.
+
+When traversing a zero-cost edge, add the node to the front.
+When traversing a one-cost edge, add it to the back.
+""",
+        "answer": """
+Use 0-1 BFS.
+
+Time: O(V+E).
+Space: O(V).
+"""
+    },
+
+    {
+        "category": "dynamic_programming",
+        "problem": """
+Given positive integers, maximize the sum without selecting adjacent
+elements.
+""",
+        "reasoning": """
+At every position there are two choices:
+
+Skip the current element.
+Take the current element, which means the previous element cannot
+be taken.
+
+This gives:
+
+dp[i] = max(dp[i-1], dp[i-2] + nums[i])
+
+Only the previous two values are required.
+""",
+        "answer": """
+Use dynamic programming with O(1) extra space.
+
+Time: O(n).
+Space: O(1).
+"""
+    },
+
+    {
+        "category": "binary_search",
+        "problem": """
+Find the minimum integer x for which a feasibility condition becomes
+true.
+""",
+        "reasoning": """
+Binary search is appropriate only if feasibility is monotonic.
+
+If x is feasible, and every larger x is also feasible, then the
+search space has a false -> true boundary.
+
+Search for the first true value.
+""",
+        "answer": """
+Use binary search on the answer.
+
+At every midpoint, evaluate feasibility.
+
+Time is O(log C) feasibility checks, where C is the search range.
+"""
+    },
+
+    {
+        "category": "algorithm_selection",
+        "problem": """
+Should binary search automatically be used whenever an answer is a
+number?
+""",
+        "reasoning": """
+No.
+
+Binary search requires an ordered or monotonic search condition.
+The fact that the answer is numeric is not enough.
+
+First establish that a feasibility predicate has a monotonic
+true/false boundary.
+""",
+        "answer": """
+Do not automatically use binary search.
+
+Check monotonicity first.
 """
     },
 
     {
         "category": "debugging",
-        "question": """
-Why can modifying a Python list while iterating over it cause elements
-to be skipped?
+        "problem": """
+A function returns the first unique character but returns None too
+early.
+
+for c in s:
+    if counts[c] == 1:
+        return c
+    return None
+
+Find the bug.
 """,
         "reasoning": """
-Removing an element shifts later elements toward the beginning of the
-list. The iterator then advances, potentially skipping the element that
-was shifted into the current position.
+The return None statement is inside the loop.
 
-A safer approach is to create a new list or iterate over a copy when
-removing elements.
+Therefore the function stops after checking only the first character
+that is not unique.
+
+The failure is control flow, not the counting logic.
 """,
         "answer": """
-The indexes shift when an element is removed, so the iterator can skip
-elements. Prefer constructing a new list or iterating over a copy.
+Move return None outside the loop.
 """
     },
 
     {
-        "category": "math",
-        "question": """
-A train travels 120 km at 60 km/h and another 120 km at 80 km/h.
-What is its average speed?
+        "category": "complexity",
+        "problem": """
+What is the complexity of:
+
+result = []
+for x in values:
+    if x not in result:
+        result.append(x)
 """,
         "reasoning": """
-Average speed is total distance divided by total time.
+Membership testing in a Python list is O(n).
 
-The first 120 km takes 2 hours.
-The second 120 km takes 1.5 hours.
+That operation occurs for each input element.
 
-Total distance is 240 km and total time is 3.5 hours.
-Therefore the average speed is 240 / 3.5, approximately 68.57 km/h.
+Therefore the worst-case complexity is O(n²).
 """,
         "answer": """
-68.57 km/h approximately.
+Worst case:
+Time: O(n²)
+Space: O(n)
+
+A set can reduce average membership checking to O(1).
 """
     },
 
     {
-        "category": "logic",
-        "question": """
-Three boxes are labeled APPLES, ORANGES, and MIXED. Every label is
-incorrect. You may take one fruit from one box without looking inside.
-Which box should you choose?
+        "category": "optimization",
+        "problem": """
+Remove duplicates from a list while preserving original order.
 """,
         "reasoning": """
-Because every label is wrong, the box labeled MIXED cannot actually
-contain a mixture. It must contain only apples or only oranges.
+We need fast membership testing and must preserve the first
+occurrence.
 
-Taking one fruit from that box reveals its actual contents. The
-incorrect labels then allow the remaining boxes to be identified.
+A set provides fast membership testing while the result list
+preserves order.
 """,
         "answer": """
-Choose the box labeled MIXED.
+seen = set()
+result = []
+
+for x in values:
+    if x not in seen:
+        seen.add(x)
+        result.append(x)
+
+Average time: O(n).
+Space: O(n).
 """
     },
 
     {
-        "category": "dynamic_programming",
-        "question": """
-Given a list of positive integers, find the maximum sum obtainable
-without selecting two adjacent elements.
+        "category": "stacks",
+        "problem": """
+Determine whether parentheses, brackets, and braces are correctly
+balanced and nested.
+""",
+        "reasoning": """
+The most recently opened bracket must be the first bracket closed.
+
+That is last-in-first-out behavior, so a stack is appropriate.
+
+When opening a bracket, push it.
+When closing one, compare it with the stack top.
+""",
+        "answer": """
+Use a stack.
+
+Time: O(n).
+Space: O(n).
+"""
+    },
+
+    {
+        "category": "sliding_window",
+        "problem": """
+Find the longest substring without repeating characters.
 """,
         "reasoning": """
-For every element there are two choices: skip it or take it.
+Maintain a window containing unique characters.
 
-If we take the current element, we cannot take the previous element.
-Therefore:
+When a repeated character appears, move the left boundary beyond
+its previous occurrence.
 
-current = max(previous_best, two_positions_back + current_value)
+The right pointer only moves forward, so each character is processed
+a constant number of times.
+""",
+        "answer": """
+Use a sliding window and hashmap.
+
+Time: O(n).
+Space: O(k).
+"""
+    },
 
-Only the previous two states are required.
+    {
+        "category": "sorting",
+        "problem": """
+Find the kth largest element without fully sorting the array.
+""",
+        "reasoning": """
+Full sorting costs O(n log n), but the problem only needs one order
+statistic.
+
+Quickselect partitions around a pivot and only recursively processes
+the side containing the desired position.
 """,
         "answer": """
-def max_non_adjacent_sum(values):
-    two_back = 0
-    one_back = 0
-
-    for value in values:
-        current = max(
-            one_back,
-            two_back + value
-        )
+Quickselect has average O(n) time and O(1) auxiliary partition
+space, depending on implementation.
+"""
+    },
+
+    {
+        "category": "graphs",
+        "problem": """
+Determine whether an undirected graph is connected.
+""",
+        "reasoning": """
+Starting from any vertex, perform DFS or BFS.
+
+If every vertex is reached, the graph is connected.
+Otherwise, at least one vertex belongs to another component.
+""",
+        "answer": """
+DFS or BFS.
+
+Time: O(V+E).
+Space: O(V).
+"""
+    },
 
-        two_back = one_back
-        one_back = current
+    {
+        "category": "trees",
+        "problem": """
+Find the maximum depth of a binary tree.
+""",
+        "reasoning": """
+The depth of a node is one plus the maximum depth of its children.
 
-    return one_back
+This naturally forms a recursive recurrence:
+depth(node) = 1 + max(depth(left), depth(right)).
+""",
+        "answer": """
+Recursive DFS.
 
 Time: O(n).
-Space: O(1).
+Space: O(h), where h is tree height.
 """
     },
 
     {
-        "category": "graph",
-        "question": """
-How can you determine whether an undirected graph contains a cycle?
+        "category": "trees",
+        "problem": """
+Determine whether a binary tree is height-balanced.
 """,
         "reasoning": """
-Use DFS or BFS while tracking the parent of each node.
+Checking the height independently for every node can repeatedly
+traverse the same subtrees.
 
-When visiting a node, if an adjacent node has already been visited and
-is not the current node's parent, then there is a cycle.
+Instead, calculate height bottom-up.
 
-Every vertex and edge is processed a constant number of times.
+Return failure immediately when a subtree is unbalanced.
 """,
         "answer": """
-Use DFS or BFS with parent tracking.
+Use postorder DFS.
+
+Return height or a sentinel indicating imbalance.
 
-Time complexity: O(V + E).
-Space complexity: O(V).
+Time: O(n).
+Space: O(h).
 """
     },
 
     {
-        "category": "binary_search",
-        "question": """
-Implement binary search for a sorted Python list.
+        "category": "greedy",
+        "problem": """
+Can you always solve an optimization problem greedily by taking the
+locally cheapest option?
 """,
         "reasoning": """
-Maintain an interval containing every possible location of the target.
-Compare the middle value with the target and discard the half that
-cannot contain it.
+No.
+
+A local choice may prevent a better global solution.
 
-The interval is approximately halved on every iteration.
+A greedy algorithm needs a proof that the local choice is safe,
+usually through an exchange argument or another greedy property.
 """,
         "answer": """
-def binary_search(values, target):
-    left = 0
-    right = len(values) - 1
+Do not assume greedy works.
+Find a counterexample or prove the greedy choice is always safe.
+"""
+    },
 
-    while left <= right:
-        mid = left + (right - left) // 2
+    {
+        "category": "algorithm_selection",
+        "problem": """
+You have a problem where a state can be reached in multiple ways,
+and future options depend on how that state was reached. Should you
+store only one distance per node?
+""",
+        "reasoning": """
+Not necessarily.
 
-        if values[mid] == target:
-            return mid
+If the future behavior depends on additional information, that
+information is part of the state.
 
-        if values[mid] < target:
-            left = mid + 1
-        else:
-            right = mid - 1
+For example, whether a discount has been used creates two distinct
+states even when the physical node is identical.
+""",
+        "answer": """
+Expand the state representation.
 
-    return -1
+Use (node, extra_state) rather than only node.
+"""
+    },
 
-Time: O(log n).
-Space: O(1).
+    {
+        "category": "verification",
+        "problem": """
+How should a newly written algorithm be tested?
+""",
+        "reasoning": """
+Do not test only the normal case.
+
+Use:
+- smallest valid input
+- empty input when allowed
+- duplicate values
+- negative values
+- boundary values
+- already sorted/reversed data
+- cases where the answer is impossible
+- cases with multiple optimal answers
+- large inputs for complexity
+""",
+        "answer": """
+Test normal cases, edge cases, adversarial cases, and large cases.
 """
     },
 
     {
         "category": "complexity",
-        "question": """
-Why does having two nested loops not automatically mean an algorithm is
-O(n^2)?
+        "problem": """
+An algorithm performs a binary search and runs Dijkstra for every
+binary-search step. What happens to the complexity?
 """,
         "reasoning": """
-Big-O complexity depends on the total number of operations, not merely
-the visual nesting of loops.
+The costs multiply.
 
-If an inner pointer only moves forward across the entire execution, it
-may move at most n times overall even though it is inside another loop.
-The total work can therefore be O(n).
+If Dijkstra costs O(E log V) and binary search performs O(log C)
+iterations, the total is:
+
+O(E log V log C)
+
+It cannot simply be described as O(E log V).
 """,
         "answer": """
-Nested loops are not automatically O(n^2). Count the total number of
-operations performed across the complete execution.
+Multiply nested algorithm costs.
+
+Total:
+O(E log V log C).
 """
     },
 
     {
-        "category": "optimization",
-        "question": """
-A Python program performs millions of membership checks against a large
-list. How could you optimize it?
+        "category": "coding",
+        "problem": """
+Write a Python function that merges overlapping intervals.
 """,
         "reasoning": """
-List membership is O(n) on average because Python may scan many elements.
-A set uses hashing and provides expected O(1) membership checks.
+Sort intervals by starting point.
+
+After sorting, the next interval either overlaps the current interval
+or starts after it ends.
 
-If ordering and duplicate preservation are not required, a set is
-usually a better structure for frequent membership testing.
+If it overlaps, extend the current end.
+Otherwise, finalize the current interval and start a new one.
 """,
         "answer": """
-Replace the list with a set when appropriate:
+Sort first, then scan.
 
-identifiers = set(identifier_list)
-
-if identifier in identifiers:
-    ...
+Time: O(n log n).
+Space: O(n) for the output.
 """
     },
 
     {
         "category": "coding",
-        "question": """
-A function works on small inputs but becomes extremely slow on large
-inputs. What should you investigate first?
+        "problem": """
+Given a string, determine whether it is a palindrome after removing
+non-alphanumeric characters and ignoring case.
 """,
         "reasoning": """
-First examine algorithmic complexity. An O(n^2) algorithm can appear
-fine on small inputs but become impractical as n grows.
+Normalization can be performed while comparing characters from both
+ends.
 
-Then inspect repeated work, unnecessary allocations, expensive I/O,
-database calls, and memory usage.
+Skip characters that are not alphanumeric.
+Compare normalized characters.
 """,
         "answer": """
-Start with time complexity and identify whether an inefficient algorithm
-is responsible. Then investigate repeated computation, I/O, allocations,
-database operations, and memory usage.
+Two pointers.
+
+Time: O(n).
+Space: O(1) if normalization is performed in-place during scanning.
+"""
+    },
+
+    {
+        "category": "debugging",
+        "problem": """
+A recursive function works on small inputs but crashes on very large
+inputs.
+""",
+        "reasoning": """
+The algorithm may be correct, but Python recursion has a recursion
+depth limitation.
+
+First determine whether recursion depth is proportional to input
+size. If so, consider an iterative stack or another formulation.
+""",
+        "answer": """
+Check recursion depth.
+Convert to iteration when necessary.
 """
     },
 
     {
-        "category": "software_architecture",
-        "question": """
-Why might an AI inference service use a queue between its API and GPU
-worker?
+        "category": "graphs",
+        "problem": """
+Why can't ordinary Dijkstra handle negative edge weights?
 """,
         "reasoning": """
-GPU inference is expensive and unlimited concurrent requests can exhaust
-GPU memory or reduce stability.
+Dijkstra relies on the fact that once the smallest tentative
+distance is selected, no later path can improve it.
 
-A queue provides controlled concurrency and backpressure. It also lets
-the API layer and inference workers scale independently.
+A negative edge can produce a cheaper path later, violating that
+assumption.
 """,
         "answer": """
-A queue controls inference concurrency, provides backpressure, handles
-traffic spikes, protects GPU memory, and separates API scaling from
-inference-worker scaling.
+Negative edges invalidate Dijkstra's greedy correctness condition.
+Consider Bellman-Ford or another algorithm appropriate to the graph.
 """
     },
 
     {
-        "category": "edge_cases",
-        "question": """
-What edge cases should be considered when writing a function that finds
-the second largest distinct number in a list?
+        "category": "math",
+        "problem": """
+How can you determine whether an integer is a power of two?
 """,
         "reasoning": """
-Consider an empty list, one distinct value, duplicate maximum values,
-negative numbers, and lists containing exactly two distinct values.
+A positive power of two has exactly one bit set in binary.
 
-The word distinct means repeated copies of the maximum do not count as
-a second value.
+For positive n:
+n & (n - 1) == 0
+exactly when n is a power of two.
 """,
         "answer": """
-Important cases include empty input, fewer than two distinct values,
-duplicates, negative values, and exactly two distinct values.
+Check:
+
+n > 0 and (n & (n - 1)) == 0
 """
     },
 
     {
-        "category": "probability",
-        "question": """
-A fair six-sided die is rolled twice. What is the probability that the
-second roll is greater than the first?
+        "category": "algorithm_selection",
+        "problem": """
+You are given a problem with n up to 200,000. A proposed solution
+uses O(n²). What should you investigate?
 """,
         "reasoning": """
-There are 36 equally likely ordered outcomes.
+At n = 200,000, quadratic work is generally too large.
 
-For every pair of different values, exactly one ordering has the second
-roll greater than the first. There are 6 choose 2 = 15 such pairs.
+Look for a structural improvement:
+hashing, sorting, two pointers, prefix sums, binary search,
+divide-and-conquer, a heap, graph algorithms, or dynamic programming.
+""",
+        "answer": """
+Inspect the O(n²) bottleneck and search for an O(n log n) or O(n)
+formulation.
+"""
+    },
 
-Therefore the probability is 15/36 = 5/12.
+    {
+        "category": "problem_solving",
+        "problem": """
+A solution works on the examples but fails hidden tests. What
+should you investigate first?
+""",
+        "reasoning": """
+Check assumptions.
+
+Typical causes:
+incorrect boundary handling,
+empty inputs,
+duplicate values,
+integer overflow,
+incorrect state transitions,
+wrong complexity,
+or an algorithm that only works under unstated assumptions.
 """,
         "answer": """
-5/12.
+Use adversarial and edge-case testing and verify the algorithm's
+invariants.
+"""
+    },
+
+    {
+        "category": "invariants",
+        "problem": """
+What is an invariant in an algorithm?
+""",
+        "reasoning": """
+An invariant is a property that remains true throughout the relevant
+part of the algorithm.
+
+Identifying one helps prove correctness and detect implementation
+errors.
+""",
+        "answer": """
+State the property that must remain true after every iteration or
+state transition.
+"""
+    },
+
+    {
+        "category": "dp",
+        "problem": """
+How do you design a dynamic programming solution to an unfamiliar
+problem?
+""",
+        "reasoning": """
+Start by identifying the smallest information needed to describe a
+subproblem.
+
+Then define:
+1. state
+2. transition
+3. base cases
+4. order of computation
+5. final state
+
+Avoid creating a state containing unnecessary information.
+""",
+        "answer": """
+Define the state and transition before writing the implementation.
+"""
+    },
+
+    {
+        "category": "debugging",
+        "problem": """
+A program produces the right answer but is too slow. What should
+you do?
+""",
+        "reasoning": """
+Correctness and efficiency are separate properties.
+
+First identify the dominant operation using complexity analysis or
+profiling.
+
+Then replace the bottleneck rather than randomly optimizing code.
+""",
+        "answer": """
+Find the dominant bottleneck, determine its complexity, and improve
+the algorithm or data structure responsible.
+"""
+    },
+
+    {
+        "category": "coding",
+        "problem": """
+Why should a dictionary store the earliest index of a prefix sum when
+finding the longest subarray with a target sum?
+""",
+        "reasoning": """
+For a fixed ending index i, a smaller earlier index creates a longer
+subarray.
+
+Therefore replacing an existing prefix-sum index with a later index
+can only make future answers shorter.
+""",
+        "answer": """
+Keep the earliest occurrence of each prefix sum.
+"""
+    },
+
+    {
+        "category": "logic",
+        "problem": """
+A statement says: If A is true, then B is true. Does B being true
+prove A is true?
+""",
+        "reasoning": """
+No.
+
+The implication only establishes A -> B.
+
+B may be true for other reasons. Inferring A from B is affirming the
+consequent.
+""",
+        "answer": """
+No. A -> B does not imply B -> A.
+"""
+    },
+
+    {
+        "category": "coding",
+        "problem": """
+A Python function needs to process a stream containing millions of
+items, but all items cannot fit comfortably in memory. What should
+you consider?
+""",
+        "reasoning": """
+Avoid loading the entire stream at once.
+
+Process incrementally, keeping only the state needed to produce the
+answer.
+
+This is a streaming algorithm.
+""",
+        "answer": """
+Process items one at a time or in bounded batches.
 """
     },
 
     {
         "category": "systems",
-        "question": """
-How would you design a service that serves a language model to many
-users while using only one GPU?
+        "problem": """
+Twenty users may request inference from the same GPU-hosted language
+model simultaneously. How can the server avoid exhausting GPU
+memory?
+""",
+        "reasoning": """
+Do not allow unlimited concurrent generation.
+
+Use a request queue, concurrency limits, and preferably batching
+where supported.
+
+The model weights can be shared, while generation memory grows with
+active requests and sequence lengths.
+""",
+        "answer": """
+Use bounded concurrency, request queuing, and controlled batching.
+"""
+    },
+
+    {
+        "category": "reasoning",
+        "problem": """
+An algorithm's proof assumes all edge weights are positive, but the
+implementation accepts negative weights. Is the proof still valid?
 """,
         "reasoning": """
-Load the model once and keep it resident on the GPU.
+No.
 
-Use controlled concurrency so requests do not independently load model
-weights. Queue requests when necessary and batch compatible requests to
-improve GPU utilization.
+The implementation's input domain is broader than the proof's
+assumptions.
 
-Limit input and output sizes, monitor GPU memory, and isolate user
-sessions from one another.
+Correctness guarantees only apply when the stated assumptions hold.
 """,
         "answer": """
-Load one shared model instance, use a request queue and controlled
-concurrency, batch requests when useful, enforce token limits, monitor
-GPU memory, and maintain separate session state for each user.
+No. Either enforce the positive-weight constraint or use an algorithm
+whose correctness supports negative weights.
 """
     }
+
 ]
 
 
 # ============================================================
-# KEYWORDS
+# EMBEDDING CACHE
 # ============================================================
 
-REASONING_KEYWORDS = {
-    "algorithm",
-    "algorithms",
-    "complexity",
-    "optimize",
-    "optimization",
-    "debug",
-    "bug",
-    "error",
-    "implement",
-    "implementation",
-    "code",
-    "coding",
-    "python",
-    "javascript",
-    "typescript",
-    "function",
-    "calculate",
-    "prove",
-    "proof",
-    "derive",
-    "analyze",
-    "analysis",
-    "compare",
-    "design",
-    "architecture",
-    "data structure",
-    "recursion",
-    "dynamic programming",
-    "graph",
-    "tree",
-    "array",
-    "database",
-    "sql",
-    "regex",
-    "performance",
-    "efficient",
-    "edge case",
-    "logic",
-    "probability",
-    "equation",
-    "mathematical",
-    "reason",
-    "reasoning",
-    "solve",
-    "solution",
-    "constraint",
-    "complex"
-}
+reasoning_embeddings = None
+
+
+def build_reasoning_embeddings():
+    """
+    Build embeddings once during startup so we don't repeatedly
+    encode the entire example library for every user request.
+    """
+    global reasoning_embeddings
+
+    if not REASONING_EXAMPLES:
+        reasoning_embeddings = None
+        return
+
+    embed_model = engine_state.get("embed_model")
+
+    if embed_model is None:
+        return
+
+    texts = []
+
+    for example in REASONING_EXAMPLES:
+        combined = (
+            example["category"]
+            + "\n"
+            + example["problem"]
+            + "\n"
+            + example["reasoning"]
+        )
+        texts.append(combined)
+
+    reasoning_embeddings = embed_model.encode(
+        texts,
+        normalize_embeddings=True,
+        convert_to_numpy=True
+    )
+
+    logger.info(
+        f"Loaded {len(REASONING_EXAMPLES)} reasoning examples."
+    )
+
+
+def retrieve_reasoning_examples(
+    query: str,
+    top_k: int = 4
+) -> list:
+    """
+    Retrieve only the most relevant examples instead of inserting
+    the entire example library into every prompt.
+    """
+
+    global reasoning_embeddings
+
+    if not REASONING_EXAMPLES:
+        return []
+
+    embed_model = engine_state.get("embed_model")
+
+    if embed_model is None:
+        return REASONING_EXAMPLES[:top_k]
+
+    try:
+        query_embedding = embed_model.encode(
+            [query],
+            normalize_embeddings=True,
+            convert_to_numpy=True
+        )[0]
+
+        if reasoning_embeddings is None:
+            build_reasoning_embeddings()
+
+        scores = np.dot(
+            reasoning_embeddings,
+            query_embedding
+        )
+
+        indices = np.argsort(scores)[::-1][:top_k]
+
+        selected = []
+
+        for index in indices:
+            example = REASONING_EXAMPLES[int(index)].copy()
+            example["_similarity"] = float(scores[int(index)])
+            selected.append(example)
+
+        return selected
+
+    except Exception as e:
+        logger.warning(
+            f"Reasoning example retrieval failed: {e}"
+        )
+
+        return REASONING_EXAMPLES[:top_k]
+
+
+def format_reasoning_examples(
+    query: str,
+    top_k: int = 4
+) -> str:
+    """
+    Convert retrieved examples into compact prompt context.
+    """
+
+    examples = retrieve_reasoning_examples(
+        query,
+        top_k=top_k
+    )
+
+    if not examples:
+        return ""
+
+    blocks = []
+
+    for i, example in enumerate(examples, 1):
+
+        blocks.append(
+            f"""
+EXAMPLE {i}
+CATEGORY: {example["category"]}
+
+PROBLEM:
+{example["problem"].strip()}
+
+REASONING PATTERN:
+{example["reasoning"].strip()}
+
+EXPECTED APPROACH:
+{example["answer"].strip()}
+""".strip()
+        )
+
+    return "\n\n---\n\n".join(blocks)
 
 
 # ============================================================
-# LIFESPAN
+# MODEL INITIALIZATION
 # ============================================================
 
 @asynccontextmanager
@@ -518,15 +1101,14 @@ async def lifespan(app: FastAPI):
     model_name = "Qwen/Qwen2.5-3B-Instruct"
 
     logger.info(
-        f"Loading {model_name} on {device}"
+        f"Loading model: {model_name}"
     )
 
     tokenizer = AutoTokenizer.from_pretrained(
         model_name
     )
 
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.pad_token = tokenizer.eos_token
 
     config = AutoConfig.from_pretrained(
         model_name
@@ -538,11 +1120,7 @@ async def lifespan(app: FastAPI):
         model_name,
         config=config,
         torch_dtype=dtype,
-        device_map=(
-            "auto"
-            if device == "cuda"
-            else None
-        )
+        device_map="auto" if device == "cuda" else None
     ).eval()
 
     embed_model = SentenceTransformer(
@@ -553,18 +1131,19 @@ async def lifespan(app: FastAPI):
     engine_state["tokenizer"] = tokenizer
     engine_state["model"] = model
     engine_state["embed_model"] = embed_model
+
     engine_state["max_history"] = 15
-    engine_state["device"] = device
 
-    logger.info(
-        f"Model successfully loaded on {device}"
-    )
+    # Number of relevant examples inserted into each prompt.
+    engine_state["reasoning_examples"] = 4
 
     logger.info(
-        f"Reasoning examples available: "
-        f"{len(REASONING_EXAMPLES)}"
+        f"Engine mapped to: {device}"
     )
 
+    # Build example embeddings once.
+    build_reasoning_embeddings()
+
     yield
 
     engine_state.clear()
@@ -575,7 +1154,7 @@ async def lifespan(app: FastAPI):
 
 
 # ============================================================
-# APP
+# FASTAPI
 # ============================================================
 
 app = FastAPI(
@@ -607,7 +1186,7 @@ class ChatRequest(BaseModel):
 
 
 # ============================================================
-# SESSION
+# SESSION MANAGEMENT
 # ============================================================
 
 def fetch_or_create_session(
@@ -617,7 +1196,7 @@ def fetch_or_create_session(
     if session_id in session_store:
         return session_store[session_id]
 
-    session = {
+    default_session = {
         "history": [],
         "last_entity": "",
         "last_web_query": "",
@@ -625,15 +1204,20 @@ def fetch_or_create_session(
         "last_web_context": []
     }
 
-    session_store[session_id] = session
+    session_store[session_id] = default_session
 
-    return session
+    return default_session
 
 
 def save_session_to_redis(
     session_id: str,
     session: dict
 ):
+    """
+    Temporary in-memory storage.
+
+    Replace with Redis later.
+    """
 
     session_store[session_id] = session
 
@@ -644,21 +1228,15 @@ def update_history_buffer(
     content: str
 ):
 
-    session["history"].append({
-        "role": role,
-        "content": content
-    })
-
-    max_history = engine_state.get(
-        "max_history",
-        15
+    session["history"].append(
+        {
+            "role": role,
+            "content": content
+        }
     )
 
-    if len(session["history"]) > max_history:
-
-        session["history"] = session[
-            "history"
-        ][-max_history:]
+    if len(session["history"]) > engine_state["max_history"]:
+        session["history"].pop(0)
 
 
 # ============================================================
@@ -714,14 +1292,9 @@ def checks_pronoun_reference(
         "after"
     }
 
-    words = set(
-        query.lower().split()
-    )
-
-    return bool(
-        words.intersection(
-            pronoun_references
-        )
+    return any(
+        word in pronoun_references
+        for word in query.lower().split()
     )
 
 
@@ -730,47 +1303,30 @@ def is_followup(
     session: dict
 ) -> bool:
 
-    if not session.get(
-        "last_entity"
-    ):
-
+    if not session["last_entity"]:
         return False
 
     scores = []
 
     try:
-
         scores.append(
             calculate_semantic_similarity(
                 query,
-                session[
-                    "last_entity"
-                ]
+                session["last_entity"]
             )
         )
-
     except Exception:
-
         pass
 
     try:
-
-        last_response = session.get(
-            "last_response",
-            ""
-        )
-
-        if last_response:
-
+        if session["last_response"]:
             scores.append(
                 calculate_semantic_similarity(
                     query,
-                    last_response[:500]
+                    session["last_response"][:500]
                 )
             )
-
     except Exception:
-
         pass
 
     best_match = max(
@@ -799,9 +1355,7 @@ def execute_llm_generation(
 
     inputs = tokenizer(
         prompt,
-        return_tensors="pt",
-        truncation=True,
-        max_length=8192
+        return_tensors="pt"
     )
 
     inputs = {
@@ -811,30 +1365,27 @@ def execute_llm_generation(
 
     with torch.no_grad():
 
-        output = model.generate(
+        out = model.generate(
             **inputs,
             max_new_tokens=max_new_tokens,
-            temperature=0.20,
-            top_p=0.90,
+            temperature=0.15,
+            top_p=0.9,
             repetition_penalty=1.08,
             do_sample=True,
-            pad_token_id=tokenizer.pad_token_id,
-            eos_token_id=tokenizer.eos_token_id
+            pad_token_id=tokenizer.eos_token_id
         )
 
-    generated = output[
+    generated_tokens = out[
         0
     ][
         inputs["input_ids"].shape[1]:
     ]
 
-    result = tokenizer.decode(
-        generated,
+    return tokenizer.decode(
+        generated_tokens,
         skip_special_tokens=True
     ).strip()
 
-    return result
-
 
 # ============================================================
 # TOPIC EXTRACTION
@@ -847,11 +1398,11 @@ def run_topic_extraction(
     prompt = f"""
 Extract the primary subject of this question.
 
-Question:
+Query:
 {query}
 
 Return only the subject.
-"""
+""".strip()
 
     return execute_llm_generation(
         prompt,
@@ -860,7 +1411,7 @@ Return only the subject.
 
 
 # ============================================================
-# FOLLOW-UP QUERY REWRITE
+# FOLLOW-UP QUERY REWRITING
 # ============================================================
 
 def rewrite_followup_query(
@@ -868,42 +1419,36 @@ def rewrite_followup_query(
     session: dict
 ) -> str:
 
-    context = "\n".join(
+    history = "\n".join(
         [
-            (
-                f"User: {item.get('user', '')}\n"
-                f"Search: {item.get('search', '')}"
-            )
-            for item in session.get(
-                "last_web_context",
-                []
-            )[-5:]
+            f"User: {x['user']}\nSearch: {x['search']}"
+            for x in session["last_web_context"][-5:]
         ]
     )
 
     prompt = f"""
-Rewrite the user's follow-up as a standalone web search query.
+Entity:
+{session["last_entity"]}
 
-Previous subject:
-{session.get('last_entity', '')}
+Recent conversation:
+{history}
 
-Recent searches:
-{context}
-
-Follow-up:
+User follow-up:
 {query}
 
-Return ONLY the standalone search query.
-"""
+Rewrite the follow-up as a standalone web search query.
+
+Return only the search query.
+""".strip()
 
     return execute_llm_generation(
         prompt,
-        max_new_tokens=96
+        max_new_tokens=128
     ).split("\n")[0].strip()
 
 
 # ============================================================
-# WEB SEARCH DECISION
+# WEB SEARCH DETECTION
 # ============================================================
 
 def should_trigger_web_search(
@@ -911,7 +1456,7 @@ def should_trigger_web_search(
     session: dict
 ) -> bool:
 
-    q_lower = q.lower()
+    q = q.lower()
 
     search_triggers = [
         "who",
@@ -923,596 +1468,244 @@ def should_trigger_web_search(
         "founder",
         "ceo",
         "company",
-        "price",
-        "stock",
-        "news",
-        "latest",
-        "current",
-        "today",
-        "code",
-        "python",
-        "html"
-    ]
-
-    if any(
-        trigger in q_lower
-        for trigger in search_triggers
-    ):
-
-        return True
-
-    return is_followup(
-        q,
-        session
-    )
-
-
-# ============================================================
-# DUCKDUCKGO
-# ============================================================
-
-def isolated_blocking_ddg(
-    query_string: str
-) -> list:
-
-    try:
-
-        with DDGS() as ddgs:
-
-            results = ddgs.text(
-                query_string,
-                max_results=5
-            )
-
-            if results:
-
-                return [
-                    result["href"]
-                    for result in results
-                    if "href" in result
-                ]
-
-    except Exception as e:
-
-        logger.error(
-            f"DuckDuckGo search failed: {e}"
-        )
-
-    return []
-
-
-async def search_web_async(
-    query: str
-) -> list:
-
-    urls = await asyncio.to_thread(
-        isolated_blocking_ddg,
-        query
-    )
-
-    if not urls:
-
-        urls.append(
-            "https://en.wikipedia.org/wiki/"
-            + query.replace(
-                " ",
-                "_"
-            )
-        )
-
-    return list(
-        dict.fromkeys(urls)
-    )[:5]
-
-
-# ============================================================
-# SCRAPING
-# ============================================================
-
-async def scrape_target_url(
-    client,
-    url: str
-):
-
-    try:
-
-        response = await client.get(
-            url,
-            timeout=10.0
-        )
-
-        if response.status_code != 200:
-
-            logger.warning(
-                f"HTTP {response.status_code}: {url}"
-            )
-
-            return None
-
-        text = None
-
-        try:
-
-            text = extract(
-                response.text
-            )
-
-        except Exception:
-
-            pass
-
-        if not text:
-
-            try:
-
-                soup = BeautifulSoup(
-                    response.text,
-                    "html.parser"
-                )
-
-                text = soup.get_text(
-                    separator=" ",
-                    strip=True
-                )
-
-            except Exception:
-
-                return None
-
-        if not text:
-
-            return None
-
-        if len(
-            text.split()
-        ) < 20:
-
-            return None
-
-        return {
-            "url": url,
-            "domain": urlparse(url).netloc,
-            "text": text[:2000]
-        }
-
-    except Exception as e:
-
-        logger.warning(
-            f"Scraping error for {url}: {e}"
-        )
-
-        return None
-
-
-async def build_context_pipeline(
-    query: str
-) -> tuple:
-
-    context_blocks = []
-    sources = []
-
-    target_urls = await search_web_async(
-        query
-    )
-
-    headers = {
-        "User-Agent":
-            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-            "AppleWebKit/537.36 "
-            "(KHTML, like Gecko) "
-            "Chrome/122.0.0.0 Safari/537.36",
-        "Accept":
-            "text/html,application/xhtml+xml,"
-            "application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language":
-            "en-US,en;q=0.9"
-    }
-
-    from curl_cffi.requests import AsyncSession
-
-    async with AsyncSession(
-        impersonate="chrome",
-        headers=headers
-    ) as client:
-
-        tasks = [
-            scrape_target_url(
-                client,
-                url
-            )
-            for url in target_urls
-        ]
-
-        results = await asyncio.gather(
-            *tasks
-        )
-
-    for result in results:
-
-        if result:
-
-            context_blocks.append(
-                f"[{result['domain']}] "
-                f"{result['text']}"
-            )
-
-            sources.append(
-                result["url"]
-            )
-
-    return (
-        "\n\n".join(context_blocks),
-        list(set(sources))
-    )
-
-
-# ============================================================
-# REASONING COMPLEXITY
-# ============================================================
-
-def calculate_reasoning_complexity(
-    query: str
-) -> float:
-
-    q = query.lower()
-
-    score = 0.0
-
-    word_count = len(
-        q.split()
-    )
-
-    if word_count > 20:
-        score += 0.15
-
-    if word_count > 50:
-        score += 0.15
-
-    matches = sum(
-        1
-        for keyword in REASONING_KEYWORDS
-        if keyword in q
-    )
-
-    score += min(
-        matches * 0.08,
-        0.55
-    )
-
-    strong_phrases = [
-        "time complexity",
-        "space complexity",
-        "big o",
-        "edge case",
-        "step by step",
-        "prove that",
-        "find the bug",
-        "optimize this",
-        "implement",
-        "derive",
-        "analyze"
-    ]
-
-    if any(
-        phrase in q
-        for phrase in strong_phrases
-    ):
-
-        score += 0.25
-
-    return min(
-        score,
-        1.0
-    )
-
-
-# ============================================================
-# CODING DETECTION
-# ============================================================
-
-def detect_coding_request(
-    query: str
-) -> bool:
-
-    q = query.lower()
-
-    coding_terms = [
-        "python",
-        "javascript",
-        "typescript",
-        "java",
-        "c++",
-        "rust",
-        "golang",
+        "price",
+        "stock",
+        "news",
+        "latest",
+        "today",
+        "current",
+        "recent",
+        "update",
         "code",
-        "coding",
-        "function",
-        "class",
-        "api",
-        "debug",
-        "bug",
-        "algorithm",
-        "sql",
-        "regex",
+        "python",
         "html",
-        "css",
-        "json",
-        "docker",
-        "fastapi",
-        "flask",
-        "script",
-        "program"
+        "javascript",
+        "documentation",
+        "release",
+        "version"
     ]
 
-    return any(
-        term in q
-        for term in coding_terms
+    if any(
+        trigger in q
+        for trigger in search_triggers
+    ):
+        return True
+
+    return is_followup(
+        q,
+        session
     )
 
 
 # ============================================================
-# SELECT REASONING EXAMPLES
+# DUCKDUCKGO
 # ============================================================
 
-def select_reasoning_examples(
-    query: str,
-    count: int = 3
+def isolated_blocking_ddg(
+    query_string: str
 ) -> list:
 
-    if not REASONING_EXAMPLES:
-
-        return []
+    try:
 
-    query_lower = query.lower()
+        with DDGS() as ddgs:
 
-    query_words = set(
-        re.findall(
-            r"[a-zA-Z]{3,}",
-            query_lower
-        )
-    )
+            results = ddgs.text(
+                query_string,
+                max_results=5
+            )
 
-    scored = []
+            if results:
 
-    for example in REASONING_EXAMPLES:
+                return [
+                    r["href"]
+                    for r in results
+                    if "href" in r
+                ]
 
-        score = 0.0
+    except Exception as e:
 
-        category = example[
-            "category"
-        ].lower().replace(
-            "_",
-            " "
+        logger.error(
+            f"Official DuckDuckGo Search failed: {e}"
         )
 
-        question = example[
-            "question"
-        ].lower()
-
-        category_words = set(
-            category.split()
-        )
+    return []
 
-        question_words = set(
-            re.findall(
-                r"[a-zA-Z]{3,}",
-                question
-            )
-        )
 
-        score += len(
-            category_words &
-            query_words
-        ) * 1.5
-
-        score += min(
-            len(
-                question_words &
-                query_words
-            ) * 0.12,
-            1.5
-        )
+async def search_web_async(
+    query: str
+) -> list:
 
-        if (
-            detect_coding_request(query)
-            and example["category"]
-            in {
-                "algorithm",
-                "debugging",
-                "coding",
-                "optimization",
-                "complexity",
-                "dynamic_programming",
-                "binary_search"
-            }
-        ):
+    urls = await asyncio.to_thread(
+        isolated_blocking_ddg,
+        query
+    )
 
-            score += 1.5
+    if not urls:
 
-        scored.append(
-            (
-                score,
-                example
-            )
+        urls.append(
+            "https://en.wikipedia.org/wiki/"
+            + query.replace(" ", "_")
         )
 
-    scored.sort(
-        key=lambda item: item[0],
-        reverse=True
-    )
-
-    return [
-        item[1]
-        for item in scored[:count]
-    ]
+    return list(
+        dict.fromkeys(urls)
+    )[:5]
 
 
 # ============================================================
-# BUILD REASONING PROMPT
+# WEB SCRAPING
 # ============================================================
 
-def build_reasoning_instruction(
-    query: str
-) -> str:
+async def scrape_target_url(
+    client,
+    url: str
+):
 
-    if not REASONING_ENABLED:
+    try:
 
-        return ""
+        r = await client.get(
+            url,
+            timeout=10.0
+        )
 
-    complexity = calculate_reasoning_complexity(
-        query
-    )
+        if r.status_code != 200:
 
-    if complexity < 0.20:
+            logger.warning(
+                f"HTTP {r.status_code}: {url}"
+            )
 
-        return ""
+            return None
 
-    examples = select_reasoning_examples(
-        query,
-        REASONING_EXAMPLES_PER_REQUEST
-    )
+        text = None
 
-    demonstrations = []
+        try:
 
-    for index, example in enumerate(
-        examples,
-        1
-    ):
+            text = extract(
+                r.text
+            )
 
-        question = example[
-            "question"
-        ].strip()
+        except Exception as e:
 
-        reasoning = example[
-            "reasoning"
-        ].strip()
+            logger.warning(
+                f"Trafilatura failed for {url}: {e}"
+            )
 
-        answer = example[
-            "answer"
-        ].strip()
+        if not text:
 
-        question = question[
-            :REASONING_MAX_EXAMPLE_CHARS
-        ]
+            try:
 
-        reasoning = reasoning[
-            :REASONING_MAX_EXAMPLE_CHARS
-        ]
+                soup = BeautifulSoup(
+                    r.text,
+                    "html.parser"
+                )
 
-        answer = answer[
-            :REASONING_MAX_EXAMPLE_CHARS
-        ]
+                text = soup.get_text(
+                    separator=" ",
+                    strip=True
+                )
 
-        demonstrations.append(
-            f"""
-EXAMPLE {index}
+            except Exception as e:
 
-Problem:
-{question}
+                logger.error(
+                    f"BeautifulSoup failed for {url}: {e}"
+                )
 
-Reasoning:
-{reasoning}
+                return None
 
-Answer:
-{answer}
-"""
-        )
+        if not text or len(text.split()) < 20:
+            return None
 
-    coding_rules = ""
+        return {
+            "url": url,
+            "domain": urlparse(url).netloc,
+            "text": text[:2500]
+        }
 
-    if detect_coding_request(
-        query
-    ):
+    except Exception as e:
+
+        logger.exception(
+            f"Scraping error for {url}: {e}"
+        )
+
+        return None
 
-        coding_rules = """
-For programming questions:
-- Understand the requirements before coding.
-- Produce valid code.
-- Consider edge cases.
-- Explain important design decisions.
-- Give accurate time complexity.
-- Give accurate space complexity when relevant.
-- If debugging, identify the cause before proposing the fix.
-"""
 
-    return f"""
-REASONING GUIDANCE
+# ============================================================
+# WEB CONTEXT PIPELINE
+# ============================================================
 
-Use the following examples only as demonstrations of useful
-problem-solving patterns.
+async def build_context_pipeline(
+    query: str
+) -> tuple:
 
-IMPORTANT OUTPUT RULES:
-- Solve ONLY the current user question.
-- Do NOT repeat the examples.
-- Do NOT repeat the user's question.
-- Do NOT generate "Human:" messages.
-- Do NOT generate "Assistant:" messages.
-- Do NOT continue an example conversation.
-- Do NOT produce multiple simulated conversations.
-- Give one answer to the current question.
-- Stop after answering the current question.
+    context_blocks = []
+    extraction_sources = []
 
-For difficult problems:
-1. Identify the objective.
-2. Identify important constraints.
-3. Break the problem into useful steps.
-4. Select an appropriate method.
-5. Check the result.
-6. Give the final answer clearly.
+    target_urls = await search_web_async(
+        query
+    )
 
-{coding_rules}
+    headers = {
+        "User-Agent":
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 "
+            "(KHTML, like Gecko) "
+            "Chrome/122.0.0.0 Safari/537.36",
 
-{''.join(demonstrations)}
+        "Accept":
+            "text/html,application/xhtml+xml,"
+            "application/xml;q=0.9,image/avif,"
+            "image/webp,*/*;q=0.8",
 
-CURRENT QUESTION:
-{query}
-"""
+        "Accept-Language":
+            "en-US,en;q=0.9",
 
+        "Accept-Encoding":
+            "gzip, deflate, br",
 
-# ============================================================
-# CLEAN MODEL OUTPUT
-# ============================================================
+        "Connection":
+            "keep-alive",
 
-def clean_model_response(
-    response: str
-) -> str:
+        "Upgrade-Insecure-Requests":
+            "1"
+    }
 
-    if not response:
+    from curl_cffi.requests import AsyncSession
 
-        return ""
+    async with AsyncSession(
+        impersonate="chrome",
+        headers=headers
+    ) as client:
 
-    response = response.strip()
+        tasks = [
+            scrape_target_url(
+                client,
+                u
+            )
+            for u in target_urls
+        ]
 
-    # Remove accidental leading assistant labels.
-    response = re.sub(
-        r"^\s*assistant\s*:\s*",
-        "",
-        response,
-        flags=re.IGNORECASE
-    )
+        scraped_results = await asyncio.gather(
+            *tasks
+        )
 
-    # If the model starts generating another conversation,
-    # stop before it.
-    markers = [
-        "\nHuman:",
-        "\nUser:",
-        "\nHuman :",
-        "\nUser :"
-    ]
+    for result in scraped_results:
 
-    positions = [
-        response.find(marker)
-        for marker in markers
-        if response.find(marker) != -1
-    ]
+        if result:
 
-    if positions:
+            context_blocks.append(
+                f"[{result['domain']}] "
+                f"{result['text']}"
+            )
 
-        response = response[
-            :min(positions)
-        ].strip()
+            extraction_sources.append(
+                result["url"]
+            )
 
-    return response
+    return (
+        "\n\n".join(context_blocks),
+        list(set(extraction_sources))
+    )
 
 
 # ============================================================
@@ -1534,43 +1727,34 @@ async def process_ask_orchestration(
     if (
         use_web
         and is_followup(q, session)
-        and session.get("last_entity")
+        and session["last_entity"]
     ):
 
-        try:
-
-            search_query = (
-                rewrite_followup_query(
-                    q,
-                    session
-                )
-            )
-
-        except Exception:
-
-            search_query = q
+        search_query = rewrite_followup_query(
+            q,
+            session
+        )
 
     context = ""
     sources = []
 
+    # --------------------------------------------------------
+    # WEB SEARCH
+    # --------------------------------------------------------
+
     if use_web:
 
-        if not is_followup(
-            q,
-            session
-        ):
+        if not is_followup(q, session):
 
             try:
 
-                session[
-                    "last_entity"
-                ] = run_topic_extraction(q)
+                session["last_entity"] = (
+                    run_topic_extraction(q)
+                )
 
             except Exception:
 
-                session[
-                    "last_entity"
-                ] = q
+                session["last_entity"] = q
 
         context, sources = (
             await build_context_pipeline(
@@ -1578,9 +1762,7 @@ async def process_ask_orchestration(
             )
         )
 
-        if len(
-            context.strip()
-        ) < 150:
+        if len(context.strip()) < 150:
 
             context, sources = (
                 await build_context_pipeline(
@@ -1598,103 +1780,119 @@ async def process_ask_orchestration(
         )
 
         if len(
-            session[
-                "last_web_context"
-            ]
+            session["last_web_context"]
         ) > 5:
 
             session[
                 "last_web_context"
-            ] = session[
-                "last_web_context"
-            ][-5:]
+            ].pop(0)
 
         session[
             "last_web_query"
         ] = search_query
 
-        system_message = """
-You are Infinity GRM, a helpful and accurate AI assistant.
+    # --------------------------------------------------------
+    # RETRIEVE REASONING EXAMPLES
+    # --------------------------------------------------------
 
-Answer ONLY the current user's question.
+    reasoning_context = format_reasoning_examples(
+        q,
+        top_k=engine_state.get(
+            "reasoning_examples",
+            4
+        )
+    )
 
-Do not repeat previous conversations.
-Do not generate fake Human/Assistant turns.
-Do not continue examples.
+    # --------------------------------------------------------
+    # SYSTEM PROMPT
+    # --------------------------------------------------------
 
-When web context is provided, use it as evidence.
-Do not invent facts that are not supported by the context.
+    system_prompt = """
+You are Infinity GRM, a capable reasoning and coding assistant.
 
-For coding and reasoning problems, solve the problem carefully and
-provide a clear final answer.
+Solve problems carefully rather than jumping to the first familiar
+algorithm.
 
-You are a detailed research assistant.
-Provide a structured comprehensive answer without bullet points.
-Always use provided web context in your answer.
-The answer must be long and detailed.
-"""
+For difficult problems:
 
-        user_message = (
-            f"WEB CONTEXT:\n"
-            f"{context}\n\n"
-            f"CURRENT QUESTION:\n"
-            f"{q}"
-        )
+1. Identify exactly what the problem requires.
+2. Identify important constraints and assumptions.
+3. Determine the key property or structure.
+4. Consider tempting approaches when useful.
+5. Reject an approach if its assumptions do not hold.
+6. Choose the appropriate algorithm or data structure.
+7. Check important edge cases.
+8. Verify the result.
+9. Give the final answer clearly.
+
+For programming problems:
+- Prefer correct and efficient algorithms.
+- Respect the stated constraints.
+- Explain important implementation decisions.
+- State time and space complexity.
+- Do not claim an algorithm is O(n) if it contains a hidden
+  O(n log n), O(n²), or repeated expensive operation.
+
+Use the provided reasoning examples as patterns, not as facts that
+must be copied.
+
+If web context is provided, use it when relevant.
+Do not invent information that contradicts the provided context.
+
+Do not blindly follow an example if the current problem is different.
+""".strip()
+
+    # --------------------------------------------------------
+    # BUILD MESSAGES
+    # --------------------------------------------------------
+
+    messages = [
+        {
+            "role": "system",
+            "content": system_prompt
+        }
+    ]
 
-        messages = [
+    # --------------------------------------------------------
+    # REASONING EXAMPLES
+    # --------------------------------------------------------
+
+    if reasoning_context:
+
+        messages.append(
             {
                 "role": "system",
-                "content": system_message
+                "content":
+                    "RELEVANT REASONING EXAMPLES:\n\n"
+                    + reasoning_context
             }
-        ]
+        )
+
+    # --------------------------------------------------------
+    # WEB CONTEXT
+    # --------------------------------------------------------
+
+    if use_web:
 
-        # Only include recent actual conversation turns.
         messages.extend(
-            session[
-                "history"
-            ][-6:]
+            session["history"][-10:]
         )
 
         messages.append(
             {
                 "role": "user",
-                "content": user_message
+                "content":
+                    f"WEB CONTEXT:\n"
+                    f"{context}\n\n"
+                    f"QUESTION:\n"
+                    f"{q}"
             }
         )
 
     else:
 
-        messages = [
-            {
-                "role": "system",
-                "content": """
-You are Infinity GRM, a highly capable helpful AI assistant.
-
-Answer ONLY the current user's question.
-
-Do not repeat the question.
-Do not generate Human: or Assistant: labels.
-Do not repeat previous examples.
-Do not continue previous conversations.
-Do not output simulated conversations.
-
-For difficult reasoning questions, reason carefully before giving the
-answer.
-
-For programming questions:
-- Understand the problem.
-- Write correct code.
-- Consider edge cases.
-- Explain important reasoning.
-- Give accurate complexity analysis.
-"""
-            }
-        ]
-
         messages.extend(
-            session[
-                "history"
-            ][-6:]
+            session["history"][-8:]
         )
 
         messages.append(
@@ -1704,82 +1902,28 @@ For programming questions:
             }
         )
 
-    # ========================================================
-    # REASONING EXAMPLES
-    #
-    # Put the reasoning instruction INTO the current user
-    # message instead of creating another system-message layer.
-    # This avoids malformed chat formatting.
-    # ========================================================
-
-    try:
-
-        reasoning_instruction = (
-            build_reasoning_instruction(q)
-        )
-
-        if reasoning_instruction:
-
-            current_content = messages[-1][
-                "content"
-            ]
-
-            messages[-1][
-                "content"
-            ] = (
-                reasoning_instruction
-                + "\n\n"
-                + current_content
-            )
-
-    except Exception as e:
-
-        logger.warning(
-            f"Reasoning prompt failed safely: {e}"
-        )
-
-    # ========================================================
+    # --------------------------------------------------------
     # CHAT TEMPLATE
-    # ========================================================
-
-    tokenizer = engine_state[
-        "tokenizer"
-    ]
+    # --------------------------------------------------------
 
     compiled_prompt = (
-        tokenizer.apply_chat_template(
+        engine_state["tokenizer"]
+        .apply_chat_template(
             messages,
             tokenize=False,
             add_generation_prompt=True
         )
     )
 
-    # ========================================================
+    # --------------------------------------------------------
     # GENERATE
-    # ========================================================
-
-    response_string = (
-        execute_llm_generation(
-            compiled_prompt,
-            max_new_tokens=2048
-        )
-    )
+    # --------------------------------------------------------
 
-    response_string = clean_model_response(
-        response_string
+    response_string = execute_llm_generation(
+        compiled_prompt,
+        max_new_tokens=2048
     )
 
-    if not response_string:
-
-        response_string = (
-            "I couldn't generate a response. "
-            "Please try the question again."
-        )
-
-    # ========================================================
-    # SAVE HISTORY
-    # ========================================================
-
     session[
         "last_response"
     ] = response_string
@@ -1803,7 +1947,7 @@ For programming questions:
 
 
 # ============================================================
-# API
+# API ENDPOINTS
 # ============================================================
 
 @app.post("/query")
@@ -1813,17 +1957,8 @@ async def chat_endpoint(
 
     try:
 
-        if not request.message.strip():
-
-            raise HTTPException(
-                status_code=400,
-                detail="Message cannot be empty."
-            )
-
-        session = (
-            fetch_or_create_session(
-                request.session_id
-            )
+        session = fetch_or_create_session(
+            request.session_id
         )
 
         answer, sources = (
@@ -1843,14 +1978,10 @@ async def chat_endpoint(
             "sources": sources
         }
 
-    except HTTPException:
-
-        raise
-
     except Exception as e:
 
         logger.exception(
-            "Critical exception inside chat runtime."
+            "Critical exception inside chat runtime pipeline"
         )
 
         raise HTTPException(
@@ -1859,10 +1990,6 @@ async def chat_endpoint(
         )
 
 
-# ============================================================
-# HEALTH
-# ============================================================
-
 @app.get("/health")
 async def validation_heartbeat():
 
@@ -1870,35 +1997,26 @@ async def validation_heartbeat():
         "status": "healthy",
         "gpu_acceleration_active":
             torch.cuda.is_available(),
-        "reasoning_enabled":
-            REASONING_ENABLED,
         "reasoning_examples":
             len(REASONING_EXAMPLES)
     }
 
 
 # ============================================================
-# STATIC
+# STATIC FILES
 # ============================================================
 
 if not os.path.exists("static"):
-
     os.makedirs("static")
 
 
 app.mount(
     "/static",
-    StaticFiles(
-        directory="static"
-    ),
+    StaticFiles(directory="static"),
     name="static"
 )
 
 
-# ============================================================
-# ROOT
-# ============================================================
-
 @app.get("/")
 async def home_route_processor():