Update main.py

main.py

@@ -1,14 +1,15 @@
 import os
-import re
 import asyncio
 import logging
-from contextlib import asynccontextmanager
-from urllib.parse import urlparse
-
-import numpy as np
+import json
 import torch
+import numpy as np
+import httpx
 import uvicorn
 
+from contextlib import asynccontextmanager
+from urllib.parse import urlparse
+
 from bs4 import BeautifulSoup
 from trafilatura import extract
 from ddgs import DDGS
@@ -18,71 +19,11 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
 from pydantic import BaseModel
-from sentence_transformers import SentenceTransformer, CrossEncoder
+from sentence_transformers import SentenceTransformer
 from transformers import (
     AutoTokenizer,
     AutoModelForCausalLM,
-    AutoConfig,
-)
-
-
-# ============================================================
-# CONFIGURATION
-# ============================================================
-
-MODEL_NAME = os.getenv(
-    "MODEL_NAME",
-    "Qwen/Qwen2.5-7B-Instruct"
-)
-
-EMBED_MODEL_NAME = os.getenv(
-    "EMBED_MODEL_NAME",
-    "sentence-transformers/all-MiniLM-L6-v2"
-)
-
-RERANKER_MODEL_NAME = os.getenv(
-    "RERANKER_MODEL_NAME",
-    "BAAI/bge-reranker-base"
-)
-
-MAX_HISTORY_MESSAGES = int(
-    os.getenv("MAX_HISTORY_MESSAGES", "8")
-)
-
-MAX_REASONING_EXAMPLES = int(
-    os.getenv("MAX_REASONING_EXAMPLES", "4")
-)
-
-MAX_WEB_RESULTS = int(
-    os.getenv("MAX_WEB_RESULTS", "5")
-)
-
-MAX_WEB_CHUNKS = int(
-    os.getenv("MAX_WEB_CHUNKS", "6")
-)
-
-WEB_CHUNK_WORDS = int(
-    os.getenv("WEB_CHUNK_WORDS", "500")
-)
-
-WEB_CHUNK_OVERLAP = int(
-    os.getenv("WEB_CHUNK_OVERLAP", "75")
-)
-
-MAX_NEW_TOKENS = int(
-    os.getenv("MAX_NEW_TOKENS", "2048")
-)
-
-MAX_INPUT_TOKENS = int(
-    os.getenv("MAX_INPUT_TOKENS", "12000")
-)
-
-RAG_MIN_SIMILARITY = float(
-    os.getenv("RAG_MIN_SIMILARITY", "0.28")
-)
-
-RERANK_MIN_SCORE = float(
-    os.getenv("RERANK_MIN_SCORE", "-5.0")
+    AutoConfig
 )
 
 
@@ -92,7 +33,7 @@ RERANK_MIN_SCORE = float(
 
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
+    format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
 logger = logging.getLogger("infinitygrm")
@@ -104,1155 +45,808 @@ logger = logging.getLogger("infinitygrm")
 
 engine_state = {}
 
+# Temporary in-memory session storage
+# Replace with Redis later if needed.
 session_store = {}
 
-reasoning_embeddings = None
-
 
 # ============================================================
 # REASONING EXAMPLES
 #
-# These examples teach STRUCTURES and PATTERNS.
+# These are intentionally concise.
 #
-# They are NOT required for the model to answer.
+# 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
 #
-# The model is explicitly instructed to solve novel problems
-# from first principles when no relevant example exists.
+# You can expand this list to 200-500+ examples.
 # ============================================================
 
 REASONING_EXAMPLES = [
 
     {
-        "category": "arrays",
-        "subcategories": [
-            "prefix_sum",
-            "hashmap",
-            "subarray",
-        ],
+        "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 the sum is not monotonic.
-
-Use prefix sums. If the current prefix sum is S, an earlier prefix
-sum of S-k means the elements between those positions sum to k.
-
-Store the earliest index at which each prefix sum appears because
-the earliest occurrence produces the longest possible subarray.
+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.
+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.
-
 prefix = {0: -1}
 running_sum = 0
 best = 0
-
-For each index:
+For each index i:
     running_sum += nums[i]
-
     if running_sum - k exists:
-        update best
-
-    store running_sum only if it has not appeared before.
-
+        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": "graphs",
-        "subcategories": [
-            "shortest_path",
-            "state_expansion",
-            "dijkstra",
-        ],
         "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": """
-The important property is that whether the discount has already been
-used changes the future choices.
-
-Therefore node alone is not a sufficient state.
-
-Represent the state as:
-(node, discount_unused)
-(node, discount_used)
-
-From the unused state, an edge can be traversed normally or with the
-discount. From the used state, it must be traversed normally.
-
-Because all resulting costs are non-negative, Dijkstra can be run on
-this expanded state graph.
+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": """
-Run Dijkstra over the expanded state space.
-
-Time: O((V + E) log V).
-Space: O(V + E).
-""",
+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": "graphs",
-        "subcategories": [
-            "cycle_detection",
-            "dfs",
-            "directed_graph",
-        ],
+        "category": "algorithms",
         "problem": """
 Determine whether a directed graph contains a cycle in O(V+E).
 """,
         "reasoning": """
-A simple visited set is insufficient for directed-cycle detection.
-
+A visited set alone is insufficient for directed-cycle detection.
+A node can be completely processed without forming a cycle, while
+another edge can point back to a node currently being explored.
 Use three states:
 0 = unvisited
 1 = currently exploring
 2 = completely processed
-
-During DFS, an edge to a state-1 vertex is a back edge and proves the
-existence of a cycle.
-
-A state-2 vertex does not indicate a cycle in the current DFS path.
+An edge to a state-1 node is a back edge and proves a cycle.
 """,
         "answer": """
 Use DFS with three colors/states.
-
-Time: O(V + E).
+Time: O(V+E).
 Space: O(V).
-""",
+"""
     },
 
     {
         "category": "data_structures",
-        "subcategories": [
-            "hashmap",
-            "frequency",
-            "strings",
-        ],
         "problem": """
 Find the first non-repeating character in a string.
 """,
         "reasoning": """
 The answer depends on both frequency and original order.
-
-First count every character. Then scan the string again and return
-the first character whose frequency is one.
+First count every character.
+Then scan the string again and return the first character whose
+frequency is one.
 """,
         "answer": """
 Use a frequency hashmap followed by a second scan.
-
 Time: O(n).
 Space: O(k), where k is the number of distinct characters.
-""",
+"""
     },
 
     {
-        "category": "arrays",
-        "subcategories": [
-            "two_pointers",
-            "sorted_array",
-        ],
+        "category": "algorithms",
         "problem": """
 Given a sorted array, determine whether two numbers sum to target.
 """,
         "reasoning": """
-The sorted order lets us eliminate entire ranges of candidates.
-
-If the sum is too small, move the left pointer right.
-If the sum is too large, move the right pointer left.
-If it equals target, the pair exists.
+Because the array is sorted, two pointers can eliminate many
+possibilities at once.
+If left + right is too small, increase left.
+If it is too large, decrease right.
+If equal, the target exists.
 """,
         "answer": """
 Use two pointers.
-
 Time: O(n).
 Space: O(1).
-""",
+"""
     },
 
     {
-        "category": "graphs",
-        "subcategories": [
-            "bfs",
-            "unweighted_shortest_path",
-        ],
+        "category": "algorithms",
         "problem": """
 Find the shortest path in an unweighted graph.
 """,
         "reasoning": """
 Every edge has equal cost.
-
-BFS explores vertices by increasing number of edges from the source.
-Therefore the first time a vertex is reached, its distance is
-minimal.
+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).
+Time: O(V+E).
 Space: O(V).
-""",
+"""
     },
 
     {
-        "category": "graphs",
-        "subcategories": [
-            "dijkstra",
-            "weighted_shortest_path",
-        ],
+        "category": "algorithms",
         "problem": """
 Find the shortest path in a graph with positive weighted edges.
 """,
         "reasoning": """
 BFS is not sufficient because edges have different costs.
-
-With positive weights, Dijkstra's greedy choice is valid: the
-currently smallest unsettled distance cannot later be improved by a
-path containing additional non-negative edges.
+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).
-""",
+O((V+E) log V).
+"""
     },
 
     {
-        "category": "graphs",
-        "subcategories": [
-            "0_1_bfs",
-            "shortest_path",
-        ],
+        "category": "algorithms",
         "problem": """
 A graph has only edge weights 0 and 1. Find shortest paths.
 """,
         "reasoning": """
-Ordinary BFS treats all edges equally, which is incorrect.
-
-Dijkstra works, but the special weights allow a deque:
-zero-cost edges go to the front and one-cost edges go to the back.
-
-This preserves increasing distance order without a heap.
+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).
+Time: O(V+E).
 Space: O(V).
-""",
+"""
     },
 
     {
         "category": "dynamic_programming",
-        "subcategories": [
-            "linear_dp",
-            "state_transition",
-        ],
         "problem": """
 Given positive integers, maximize the sum without selecting adjacent
 elements.
 """,
         "reasoning": """
-At each element there are two choices.
-
-Skip it:
-dp[i] = dp[i-1]
-
-Take it:
-dp[i] = dp[i-2] + nums[i]
-
-Therefore:
-
+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 states are required.
+Only the previous two values are required.
 """,
         "answer": """
-Use dynamic programming with two rolling values.
-
+Use dynamic programming with O(1) extra space.
 Time: O(n).
 Space: O(1).
-""",
+"""
     },
 
     {
         "category": "binary_search",
-        "subcategories": [
-            "search_on_answer",
-            "monotonicity",
-        ],
         "problem": """
 Find the minimum integer x for which a feasibility condition becomes
 true.
 """,
         "reasoning": """
-Binary search on the answer is valid only when feasibility is
-monotonic.
-
-If x is feasible, every larger value must also be feasible, creating
-a false-to-true boundary.
-
-Search for the first feasible value.
+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.
-
-Perform one feasibility check per midpoint.
-
-Complexity:
-O(log C) feasibility checks, where C is the search range.
-""",
+At every midpoint, evaluate feasibility.
+Time is O(log C) feasibility checks, where C is the search range.
+"""
     },
 
     {
         "category": "algorithm_selection",
-        "subcategories": [
-            "binary_search",
-            "monotonicity",
-        ],
         "problem": """
 Should binary search automatically be used whenever an answer is a
 number?
 """,
         "reasoning": """
 No.
-
-A numeric answer is not sufficient.
-
-Binary search requires an ordered search space or a monotonic
-predicate that creates a usable boundary.
+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.
-
-Prove monotonicity first.
-""",
+Check monotonicity first.
+"""
     },
 
     {
         "category": "debugging",
-        "subcategories": [
-            "control_flow",
-            "python",
-        ],
         "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": """
 The return None statement is inside the loop.
-
-Therefore the function terminates after checking only the first
-non-unique character.
-
-The counting logic is not necessarily wrong; the control flow is.
+Therefore the function stops after checking only the first character
+that is not unique.
+The failure is control flow, not the counting logic.
 """,
         "answer": """
 Move return None outside the loop.
-""",
+"""
     },
 
     {
         "category": "complexity",
-        "subcategories": [
-            "nested_work",
-            "list_membership",
-        ],
         "problem": """
 What is the complexity of:
-
 result = []
 for x in values:
     if x not in result:
         result.append(x)
 """,
         "reasoning": """
-Membership testing in a Python list is O(n) in the worst case.
-
-That operation can occur once for every input element.
-
-Therefore the overall worst-case complexity is O(n²).
+Membership testing in a Python list is O(n).
+That operation occurs for each input element.
+Therefore the worst-case complexity is O(n²).
 """,
         "answer": """
 Worst case:
-
 Time: O(n²)
 Space: O(n)
-
-A set can provide average O(1) membership testing.
-""",
+A set can reduce average membership checking to O(1).
+"""
     },
 
     {
         "category": "optimization",
-        "subcategories": [
-            "hash_set",
-            "deduplication",
-        ],
         "problem": """
 Remove duplicates from a list while preserving original order.
 """,
         "reasoning": """
-The result must preserve the first occurrence while membership
-testing needs to be fast.
-
-Use a set for membership and a list for output ordering.
+We need fast membership testing and must preserve the first
+occurrence.
+A set provides fast membership testing while the result list
+preserves order.
 """,
         "answer": """
 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": "stacks",
-        "subcategories": [
-            "parentheses",
-            "matching",
-        ],
         "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.
-
-Opening brackets are pushed. Closing brackets must match the stack
-top.
+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",
-        "subcategories": [
-            "strings",
-            "two_pointers",
-        ],
         "problem": """
 Find the longest substring without repeating characters.
 """,
         "reasoning": """
 Maintain a window containing unique characters.
-
-When a duplicate appears, move the left boundary beyond the previous
-occurrence of that character.
-
-Both boundaries only move forward.
+When a repeated character appears, move the left boundary beyond
+its previous occurrence.
+The right pointer only moves forward, so each character is processed
+a constant number of times.
 """,
         "answer": """
-Use a sliding window with a hashmap.
-
+Use a sliding window and hashmap.
 Time: O(n).
 Space: O(k).
-""",
+"""
     },
 
     {
-        "category": "selection",
-        "subcategories": [
-            "quickselect",
-            "order_statistics",
-        ],
+        "category": "sorting",
         "problem": """
 Find the kth largest element without fully sorting the array.
 """,
         "reasoning": """
-Full sorting performs more work than necessary because only one order
-statistic is needed.
-
-Quickselect partitions around a pivot and continues only on the side
-containing the desired position.
+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": """
-Use Quickselect.
+Quickselect has average O(n) time and O(1) auxiliary partition
+space, depending on implementation.
+"""
+    },
 
-Average time: O(n).
-Worst-case time: O(n²) without appropriate pivot guarantees.
+    {
+        "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).
+"""
     },
 
     {
         "category": "trees",
-        "subcategories": [
-            "dfs",
-            "recursion",
-        ],
         "problem": """
 Find the maximum depth of a binary tree.
 """,
         "reasoning": """
 The depth of a node is one plus the maximum depth of its children.
-
-This gives the recurrence:
-
-depth(node) =
-    1 + max(depth(left), depth(right))
+This naturally forms a recursive recurrence:
+depth(node) = 1 + max(depth(left), depth(right)).
 """,
         "answer": """
-Use recursive DFS.
-
+Recursive DFS.
 Time: O(n).
-Space: O(h), where h is the tree height.
-""",
+Space: O(h), where h is tree height.
+"""
     },
 
     {
         "category": "trees",
-        "subcategories": [
-            "postorder",
-            "height",
-            "balance",
-        ],
         "problem": """
 Determine whether a binary tree is height-balanced.
 """,
         "reasoning": """
-Computing the height independently for every node can repeatedly
+Checking the height independently for every node can repeatedly
 traverse the same subtrees.
-
-Calculate heights bottom-up instead.
-
-Return failure immediately if a subtree is unbalanced.
+Instead, calculate height bottom-up.
+Return failure immediately when a subtree is unbalanced.
 """,
         "answer": """
 Use postorder DFS.
-
-Return the subtree height or a sentinel indicating imbalance.
-
+Return height or a sentinel indicating imbalance.
 Time: O(n).
 Space: O(h).
-""",
+"""
     },
 
     {
         "category": "greedy",
-        "subcategories": [
-            "proof",
-            "exchange_argument",
-        ],
         "problem": """
 Can you always solve an optimization problem greedily by taking the
 locally cheapest option?
 """,
         "reasoning": """
 No.
-
-A local choice can prevent a better global solution.
-
+A local choice may prevent a better global solution.
 A greedy algorithm needs a proof that the local choice is safe,
-often through an exchange argument or another structural property.
+usually through an exchange argument or another greedy property.
 """,
         "answer": """
 Do not assume greedy works.
-
-Prove the greedy choice is safe or construct a counterexample.
-""",
+Find a counterexample or prove the greedy choice is always safe.
+"""
     },
 
     {
         "category": "algorithm_selection",
-        "subcategories": [
-            "state_design",
-            "dynamic_programming",
-        ],
         "problem": """
-A state can be reached multiple ways, and future options depend on
-how the state was reached. Should you store only one distance per
-node?
+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 future behavior depends on additional information, that
+If the future behavior depends on additional information, that
 information is part of the state.
-
-For example, whether a discount has been used can distinguish two
-otherwise identical graph nodes.
+For example, whether a discount has been used creates two distinct
+states even when the physical node is identical.
 """,
         "answer": """
 Expand the state representation.
-
-Use something like:
-(node, extra_state)
-instead of only:
-node
-""",
+Use (node, extra_state) rather than only node.
+"""
     },
 
     {
         "category": "verification",
-        "subcategories": [
-            "testing",
-            "edge_cases",
-        ],
         "problem": """
 How should a newly written algorithm be tested?
 """,
         "reasoning": """
-Normal examples are insufficient.
-
-Test:
-- smallest valid inputs
+Do not test only the normal case.
+Use:
+- smallest valid input
 - empty input when allowed
-- duplicates
+- duplicate values
 - negative values
 - boundary values
-- sorted and reverse-sorted data
-- impossible cases
-- multiple optimal answers
-- very large inputs
-- adversarial structures
+- already sorted/reversed data
+- cases where the answer is impossible
+- cases with multiple optimal answers
+- large inputs for complexity
 """,
         "answer": """
-Use normal, edge-case, adversarial, and large-input tests.
-""",
+Test normal cases, edge cases, adversarial cases, and large cases.
+"""
     },
 
     {
         "category": "complexity",
-        "subcategories": [
-            "nested_algorithms",
-        ],
         "problem": """
-An algorithm performs binary search and runs Dijkstra for every
+An algorithm performs a binary search and runs Dijkstra for every
 binary-search step. What happens to the complexity?
 """,
         "reasoning": """
-Nested algorithm costs multiply.
-
+The costs multiply.
 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": """
-Multiply the costs of nested operations.
-
+Multiply nested algorithm costs.
 Total:
 O(E log V log C).
-""",
+"""
     },
 
     {
-        "category": "intervals",
-        "subcategories": [
-            "sorting",
-            "merging",
-        ],
+        "category": "coding",
         "problem": """
 Write a Python function that merges overlapping intervals.
 """,
         "reasoning": """
 Sort intervals by starting point.
-
 After sorting, the next interval either overlaps the current interval
 or starts after it ends.
-
-When they overlap, extend the current endpoint. Otherwise finalize
-the current interval and start a new one.
+If it overlaps, extend the current end.
+Otherwise, finalize the current interval and start a new one.
 """,
         "answer": """
-Sort by interval start, then scan.
-
+Sort first, then scan.
 Time: O(n log n).
 Space: O(n) for the output.
-""",
+"""
     },
 
     {
-        "category": "strings",
-        "subcategories": [
-            "two_pointers",
-            "normalization",
-        ],
+        "category": "coding",
         "problem": """
-Determine whether a string is a palindrome after removing
+Given a string, determine whether it is a palindrome after removing
 non-alphanumeric characters and ignoring case.
 """,
         "reasoning": """
-Compare characters from both ends while skipping non-alphanumeric
-characters.
-
-Normalize characters before comparison.
-
-This avoids constructing a second normalized string.
+Normalization can be performed while comparing characters from both
+ends.
+Skip characters that are not alphanumeric.
+Compare normalized characters.
 """,
         "answer": """
-Use two pointers.
-
+Two pointers.
 Time: O(n).
-Auxiliary space: O(1).
-""",
+Space: O(1) if normalization is performed in-place during scanning.
+"""
     },
 
     {
         "category": "debugging",
-        "subcategories": [
-            "recursion",
-            "stack",
-        ],
         "problem": """
 A recursive function works on small inputs but crashes on very large
 inputs.
 """,
         "reasoning": """
-The algorithm may be logically correct but exceed Python's recursion
-depth.
-
-Determine whether recursion depth grows with input size.
-
-If so, an iterative formulation using an explicit stack may avoid the
-language recursion limit.
+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 and convert to iteration when appropriate.
-""",
+Check recursion depth.
+Convert to iteration when necessary.
+"""
     },
 
     {
         "category": "graphs",
-        "subcategories": [
-            "negative_weights",
-            "shortest_path",
-        ],
         "problem": """
 Why can't ordinary Dijkstra handle negative edge weights?
 """,
         "reasoning": """
-Dijkstra assumes that once the smallest tentative distance is
-selected, no future path can improve it.
-
-A negative edge can create a cheaper path later, violating that
-greedy assumption.
+Dijkstra relies on the fact that once the smallest tentative
+distance is selected, no later path can improve it.
+A negative edge can produce a cheaper path later, violating that
+assumption.
 """,
         "answer": """
-Negative weights invalidate Dijkstra's correctness condition.
-
-Consider Bellman-Ford or another algorithm suitable for the input.
-""",
+Negative edges invalidate Dijkstra's greedy correctness condition.
+Consider Bellman-Ford or another algorithm appropriate to the graph.
+"""
     },
 
     {
         "category": "math",
-        "subcategories": [
-            "bitwise",
-            "powers_of_two",
-        ],
         "problem": """
 How can you determine whether an integer is a power of two?
 """,
         "reasoning": """
-A positive power of two has exactly one bit set.
-
+A positive power of two has exactly one bit set in binary.
 For positive n:
-
 n & (n - 1) == 0
-
-is true exactly when n has one set bit.
+exactly when n is a power of two.
 """,
         "answer": """
 Check:
-
 n > 0 and (n & (n - 1)) == 0
-""",
+"""
     },
 
     {
         "category": "algorithm_selection",
-        "subcategories": [
-            "complexity",
-            "optimization",
-        ],
         "problem": """
-You are given a problem where n can be 200,000. A proposed solution
+You are given a problem with n up to 200,000. A proposed solution
 uses O(n²). What should you investigate?
 """,
         "reasoning": """
-Quadratic work is generally too large at this input scale.
-
-Look for structural improvements such as hashing, sorting, two
-pointers, prefix sums, binary search, heaps, graph algorithms, or
-dynamic programming.
+At n = 200,000, quadratic work is generally too large.
+Look for a structural improvement:
+hashing, sorting, two pointers, prefix sums, binary search,
+divide-and-conquer, a heap, graph algorithms, or dynamic programming.
 """,
         "answer": """
-Identify the O(n²) bottleneck and search for an O(n log n) or O(n)
+Inspect the O(n²) bottleneck and search for an O(n log n) or O(n)
 formulation.
-""",
+"""
     },
 
     {
         "category": "problem_solving",
-        "subcategories": [
-            "debugging",
-            "edge_cases",
-        ],
         "problem": """
-A solution works on examples but fails hidden tests. What should be
-investigated?
+A solution works on the examples but fails hidden tests. What
+should you investigate first?
 """,
         "reasoning": """
-Check unstated assumptions.
-
-Typical causes include:
-incorrect boundaries,
+Check assumptions.
+Typical causes:
+incorrect boundary handling,
 empty inputs,
-duplicates,
-overflow,
+duplicate values,
+integer overflow,
 incorrect state transitions,
 wrong complexity,
-or an algorithm that only works on the sample structure.
+or an algorithm that only works under unstated assumptions.
 """,
         "answer": """
 Use adversarial and edge-case testing and verify the algorithm's
 invariants.
-""",
+"""
     },
 
     {
         "category": "invariants",
-        "subcategories": [
-            "correctness",
-            "proof",
-        ],
         "problem": """
 What is an invariant in an algorithm?
 """,
         "reasoning": """
 An invariant is a property that remains true throughout the relevant
 part of the algorithm.
-
-It can be used both to prove correctness and to detect implementation
+Identifying one helps prove correctness and detect implementation
 errors.
 """,
         "answer": """
-State the property that must remain true after every relevant
-iteration or state transition.
-""",
+State the property that must remain true after every iteration or
+state transition.
+"""
     },
 
     {
-        "category": "dynamic_programming",
-        "subcategories": [
-            "state_design",
-            "transitions",
-        ],
+        "category": "dp",
         "problem": """
 How do you design a dynamic programming solution to an unfamiliar
 problem?
 """,
         "reasoning": """
-Start by identifying the smallest information required to describe a
+Start by identifying the smallest information needed to describe a
 subproblem.
-
 Then define:
 1. state
 2. transition
 3. base cases
-4. computation order
+4. order of computation
 5. final state
-
-Avoid putting unnecessary information into the state.
+Avoid creating a state containing unnecessary information.
 """,
         "answer": """
-Define the state and transition before implementing the DP.
-""",
+Define the state and transition before writing the implementation.
+"""
     },
 
     {
-        "category": "optimization",
-        "subcategories": [
-            "profiling",
-            "complexity",
-        ],
+        "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 improve the actual bottleneck instead of randomly optimizing
-unrelated code.
+Then replace the bottleneck rather than randomly optimizing code.
 """,
         "answer": """
 Find the dominant bottleneck, determine its complexity, and improve
-the responsible algorithm or data structure.
-""",
+the algorithm or data structure responsible.
+"""
     },
 
     {
-        "category": "arrays",
-        "subcategories": [
-            "prefix_sum",
-            "hashmap",
-        ],
+        "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, a smaller earlier index creates a longer
+For a fixed ending index i, a smaller earlier index creates a longer
 subarray.
-
-Replacing an existing prefix-sum index with a later index can only
-make future answers shorter.
+Therefore replacing an existing prefix-sum index with a later index
+can only make future answers shorter.
 """,
         "answer": """
-Keep the earliest occurrence of every prefix sum.
-""",
+Keep the earliest occurrence of each prefix sum.
+"""
     },
 
     {
         "category": "logic",
-        "subcategories": [
-            "implication",
-            "affirming_consequent",
-        ],
         "problem": """
 A statement says: If A is true, then B is true. Does B being true
 prove A is true?
 """,
         "reasoning": """
 No.
-
-The implication establishes A -> B, not B -> A.
-
-B may be true for another reason.
+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",
-        "subcategories": [
-            "gpu_inference",
-            "concurrency",
-            "batching",
-        ],
         "problem": """
 Twenty users may request inference from the same GPU-hosted language
 model simultaneously. How can the server avoid exhausting GPU
 memory?
 """,
         "reasoning": """
-Model weights can be shared, but generation memory grows with active
-requests and sequence lengths.
-
-Unlimited concurrency can therefore exhaust memory.
-
-Use request queuing, bounded concurrency, and controlled batching.
+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": "correctness",
-        "subcategories": [
-            "assumptions",
-            "proof",
-        ],
+        "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": """
 No.
-
-The implementation accepts inputs outside the assumptions used by
-the proof.
-
-Correctness guarantees only apply to inputs satisfying those
+The implementation's input domain is broader than the proof's
 assumptions.
+Correctness guarantees only apply when the stated assumptions hold.
 """,
         "answer": """
-Either enforce the positive-weight constraint or use an algorithm
+No. Either enforce the positive-weight constraint or use an algorithm
 whose correctness supports negative weights.
-""",
-    },
-]
-
-
-# ============================================================
-# CATEGORY ROUTING
-# ============================================================
+"""
+    }
 
-CATEGORY_HINTS = {
-    "graphs": [
-        "graph",
-        "graphs",
-        "vertex",
-        "vertices",
-        "edge",
-        "edges",
-        "shortest path",
-        "dijkstra",
-        "bfs",
-        "dfs",
-        "topological",
-        "cycle",
-        "connected",
-    ],
-
-    "dynamic_programming": [
-        "dynamic programming",
-        "dp",
-        "subproblem",
-        "transition",
-        "memoization",
-        "tabulation",
-    ],
-
-    "binary_search": [
-        "binary search",
-        "monotonic",
-        "first true",
-        "last true",
-        "search on answer",
-    ],
-
-    "sliding_window": [
-        "sliding window",
-        "substring",
-        "subarray",
-        "window",
-    ],
-
-    "trees": [
-        "binary tree",
-        "tree",
-        "bst",
-        "subtree",
-        "node",
-        "leaf",
-    ],
-
-    "debugging": [
-        "bug",
-        "debug",
-        "error",
-        "crash",
-        "wrong answer",
-        "fails",
-        "broken",
-    ],
-
-    "complexity": [
-        "complexity",
-        "big o",
-        "time complexity",
-        "space complexity",
-        "too slow",
-        "performance",
-    ],
-
-    "arrays": [
-        "array",
-        "arrays",
-        "subarray",
-        "prefix sum",
-        "two pointers",
-    ],
-
-    "strings": [
-        "string",
-        "substring",
-        "character",
-        "palindrome",
-    ],
-
-    "systems": [
-        "gpu",
-        "cuda",
-        "server",
-        "concurrency",
-        "batching",
-        "memory",
-        "inference",
-        "api",
-    ],
-}
-
-
-def detect_categories(query: str) -> set:
-    q = query.lower()
-
-    categories = set()
-
-    for category, keywords in CATEGORY_HINTS.items():
-        for keyword in keywords:
-
-            if " " in keyword:
-                if keyword in q:
-                    categories.add(category)
-                    break
-            else:
-                if re.search(
-                    rf"\b{re.escape(keyword)}\b",
-                    q,
-                ):
-                    categories.add(category)
-                    break
-
-    return categories
+]
 
 
 # ============================================================
-# EMBEDDINGS
+# EMBEDDING CACHE
 # ============================================================
 
-def example_to_embedding_text(example: dict) -> str:
-
-    return (
-        f"CATEGORY: {example['category']}\n"
-        f"SUBCATEGORIES: "
-        f"{', '.join(example.get('subcategories', []))}\n"
-        f"PROBLEM: {example['problem']}\n"
-        f"REASONING: {example['reasoning']}\n"
-        f"ANSWER: {example['answer']}"
-    )
+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:
@@ -1264,28 +858,37 @@ def build_reasoning_embeddings():
     if embed_model is None:
         return
 
-    texts = [
-        example_to_embedding_text(example)
-        for example in REASONING_EXAMPLES
-    ]
+    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,
-        show_progress_bar=False,
+        convert_to_numpy=True
     )
 
     logger.info(
-        "Built embeddings for %d reasoning examples.",
-        len(REASONING_EXAMPLES),
+        f"Loaded {len(REASONING_EXAMPLES)} reasoning examples."
     )
 
 
 def retrieve_reasoning_examples(
     query: str,
-    top_k: int = 4,
+    top_k: int = 4
 ) -> list:
+    """
+    Retrieve only the most relevant examples instead of inserting
+    the entire example library into every prompt.
+    """
 
     global reasoning_embeddings
 
@@ -1298,120 +901,50 @@ def retrieve_reasoning_examples(
         return REASONING_EXAMPLES[:top_k]
 
     try:
-
-        if reasoning_embeddings is None:
-            build_reasoning_embeddings()
-
         query_embedding = embed_model.encode(
             [query],
             normalize_embeddings=True,
-            convert_to_numpy=True,
-            show_progress_bar=False,
+            convert_to_numpy=True
         )[0]
 
+        if reasoning_embeddings is None:
+            build_reasoning_embeddings()
+
         scores = np.dot(
             reasoning_embeddings,
-            query_embedding,
+            query_embedding
         )
 
-        ranked_indices = np.argsort(scores)[::-1]
-
-        query_categories = detect_categories(query)
+        indices = np.argsort(scores)[::-1][:top_k]
 
         selected = []
-        selected_indices = set()
-
-        # ----------------------------------------------------
-        # First pass: category-compatible examples
-        # ----------------------------------------------------
-
-        for index in ranked_indices:
-
-            index = int(index)
-
-            example = REASONING_EXAMPLES[index]
-
-            score = float(scores[index])
-
-            if score < RAG_MIN_SIMILARITY:
-                continue
-
-            if (
-                query_categories
-                and example["category"] not in query_categories
-            ):
-                continue
-
-            selected.append(
-                {
-                    **example,
-                    "_similarity": score,
-                }
-            )
-
-            selected_indices.add(index)
-
-            if len(selected) >= top_k:
-                break
-
-        # ----------------------------------------------------
-        # Second pass: semantic fallback
-        #
-        # This is crucial.
-        #
-        # If no category-specific example exists, semantic
-        # similarity can still find a structurally useful
-        # example.
-        # ----------------------------------------------------
-
-        if len(selected) < top_k:
-
-            for index in ranked_indices:
 
-                index = int(index)
-
-                if index in selected_indices:
-                    continue
-
-                score = float(scores[index])
-
-                if score < RAG_MIN_SIMILARITY:
-                    continue
-
-                example = REASONING_EXAMPLES[index]
-
-                selected.append(
-                    {
-                        **example,
-                        "_similarity": score,
-                    }
-                )
-
-                selected_indices.add(index)
-
-                if len(selected) >= top_k:
-                    break
+        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(
-            "Reasoning retrieval failed: %s",
-            e,
+            f"Reasoning example retrieval failed: {e}"
         )
 
-        return []
+        return REASONING_EXAMPLES[:top_k]
 
 
 def format_reasoning_examples(
     query: str,
-    top_k: int = 4,
+    top_k: int = 4
 ) -> str:
+    """
+    Convert retrieved examples into compact prompt context.
+    """
 
     examples = retrieve_reasoning_examples(
         query,
-        top_k=top_k,
+        top_k=top_k
     )
 
     if not examples:
@@ -1425,16 +958,11 @@ def format_reasoning_examples(
             f"""
 EXAMPLE {i}
 CATEGORY: {example["category"]}
-SUBCATEGORIES: {", ".join(example.get("subcategories", []))}
-RELEVANCE: {example["_similarity"]:.3f}
-
 PROBLEM:
 {example["problem"].strip()}
-
-APPROACH SUMMARY:
+REASONING PATTERN:
 {example["reasoning"].strip()}
-
-ANSWER:
+EXPECTED APPROACH:
 {example["answer"].strip()}
 """.strip()
         )
@@ -1443,90 +971,426 @@ ANSWER:
 
 
 # ============================================================
-# TEXT UTILITIES
+# MODEL INITIALIZATION
 # ============================================================
 
-def normalize_text(text: str) -> str:
+@asynccontextmanager
+async def lifespan(app: FastAPI):
 
-    text = re.sub(
-        r"\s+",
-        " ",
-        text or "",
+    logger.info(
+        "Initializing neural weights and engine dependencies..."
     )
 
-    return text.strip()
+    device = (
+        "cuda"
+        if torch.cuda.is_available()
+        else "cpu"
+    )
 
+    dtype = (
+        torch.float16
+        if device == "cuda"
+        else torch.float32
+    )
 
-def chunk_text(
-    text: str,
-    chunk_size: int = WEB_CHUNK_WORDS,
-    overlap: int = WEB_CHUNK_OVERLAP,
-) -> list:
+    model_name = "Qwen/Qwen2.5-7B-Instruct"
 
-    words = normalize_text(text).split()
+    logger.info(
+        f"Loading model: {model_name}"
+    )
 
-    if not words:
-        return []
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_name
+    )
+
+    tokenizer.pad_token = tokenizer.eos_token
+
+    config = AutoConfig.from_pretrained(
+        model_name
+    )
+
+    config.pad_token_id = tokenizer.eos_token_id
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        config=config,
+        torch_dtype=dtype,
+        device_map="auto" if device == "cuda" else None
+    ).eval()
+
+    embed_model = SentenceTransformer(
+        "sentence-transformers/all-MiniLM-L6-v2",
+        device=device
+    )
+
+    engine_state["tokenizer"] = tokenizer
+    engine_state["model"] = model
+    engine_state["embed_model"] = embed_model
+
+    engine_state["max_history"] = 15
+
+    # Number of relevant examples inserted into each prompt.
+    engine_state["reasoning_examples"] = 4
+
+    logger.info(
+        f"Engine mapped to: {device}"
+    )
+
+    # Build example embeddings once.
+    build_reasoning_embeddings()
+
+    yield
+
+    engine_state.clear()
+
+    logger.info(
+        "Application context fully flushed."
+    )
+
+
+# ============================================================
+# FASTAPI
+# ============================================================
+
+app = FastAPI(
+    title="Infinity GRM Engine",
+    lifespan=lifespan
+)
+
+
+# ============================================================
+# CORS
+# ============================================================
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ============================================================
+# REQUEST MODEL
+# ============================================================
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: str
+
+
+# ============================================================
+# SESSION MANAGEMENT
+# ============================================================
+
+def fetch_or_create_session(
+    session_id: str
+) -> dict:
+
+    if session_id in session_store:
+        return session_store[session_id]
+
+    default_session = {
+        "history": [],
+        "last_entity": "",
+        "last_web_query": "",
+        "last_response": "",
+        "last_web_context": []
+    }
+
+    session_store[session_id] = default_session
+
+    return default_session
+
+
+def save_session_to_redis(
+    session_id: str,
+    session: dict
+):
+    """
+    Temporary in-memory storage.
+    Replace with Redis later.
+    """
 
-    chunks = []
+    session_store[session_id] = session
 
-    start = 0
 
-    while start < len(words):
+def update_history_buffer(
+    session: dict,
+    role: str,
+    content: str
+):
+
+    session["history"].append(
+        {
+            "role": role,
+            "content": content
+        }
+    )
+
+    if len(session["history"]) > engine_state["max_history"]:
+        session["history"].pop(0)
+
+
+# ============================================================
+# SEMANTIC SIMILARITY
+# ============================================================
+
+def calculate_semantic_similarity(
+    a: str,
+    b: str
+) -> float:
 
-        end = min(
-            start + chunk_size,
-            len(words),
+    embedder = engine_state["embed_model"]
+
+    embeddings = embedder.encode(
+        [a, b],
+        normalize_embeddings=True
+    )
+
+    return float(
+        np.dot(
+            embeddings[0],
+            embeddings[1]
         )
+    )
+
+
+# ============================================================
+# FOLLOW-UP DETECTION
+# ============================================================
+
+def checks_pronoun_reference(
+    query: str
+) -> bool:
+
+    pronoun_references = {
+        "he",
+        "him",
+        "his",
+        "she",
+        "her",
+        "hers",
+        "they",
+        "them",
+        "their",
+        "it",
+        "its",
+        "that",
+        "those",
+        "this",
+        "these",
+        "then",
+        "next",
+        "after"
+    }
+
+    return any(
+        word in pronoun_references
+        for word in query.lower().split()
+    )
+
+
+def is_followup(
+    query: str,
+    session: dict
+) -> bool:
+
+    if not session["last_entity"]:
+        return False
 
-        chunk = " ".join(
-            words[start:end]
+    scores = []
+
+    try:
+        scores.append(
+            calculate_semantic_similarity(
+                query,
+                session["last_entity"]
+            )
         )
+    except Exception:
+        pass
+
+    try:
+        if session["last_response"]:
+            scores.append(
+                calculate_semantic_similarity(
+                    query,
+                    session["last_response"][:500]
+                )
+            )
+    except Exception:
+        pass
+
+    best_match = max(
+        scores,
+        default=0
+    )
+
+    return (
+        best_match > 0.45
+        or len(query.split()) <= 3
+        or checks_pronoun_reference(query)
+    )
+
 
-        if chunk:
-            chunks.append(chunk)
+# ============================================================
+# LLM GENERATION
+# ============================================================
 
-        if end >= len(words):
-            break
+def execute_llm_generation(
+    prompt: str,
+    max_new_tokens: int = 2048
+) -> str:
 
-        start = max(
-            start + 1,
-            end - overlap,
+    tokenizer = engine_state["tokenizer"]
+    model = engine_state["model"]
+
+    inputs = tokenizer(
+        prompt,
+        return_tensors="pt"
+    )
+
+    inputs = {
+        key: value.to(model.device)
+        for key, value in inputs.items()
+    }
+
+    with torch.no_grad():
+
+        out = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=0.15,
+            top_p=0.9,
+            repetition_penalty=1.08,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
         )
 
-    return chunks
+    generated_tokens = out[
+        0
+    ][
+        inputs["input_ids"].shape[1]:
+    ]
+
+    return tokenizer.decode(
+        generated_tokens,
+        skip_special_tokens=True
+    ).strip()
+
 
+# ============================================================
+# TOPIC EXTRACTION
+# ============================================================
 
-def trim_text_by_tokens(
-    text: str,
-    max_tokens: int,
+def run_topic_extraction(
+    query: str
 ) -> str:
 
-    tokenizer = engine_state.get("tokenizer")
+    prompt = f"""
+Extract the primary subject of this question.
+Query:
+{query}
+Return only the subject.
+""".strip()
+
+    return execute_llm_generation(
+        prompt,
+        max_new_tokens=64
+    ).split("\n")[0].strip()
+
+
+# ============================================================
+# FOLLOW-UP QUERY REWRITING
+# ============================================================
 
-    if tokenizer is None:
-        return text
+def rewrite_followup_query(
+    query: str,
+    session: dict
+) -> str:
 
-    tokens = tokenizer.encode(
-        text,
-        add_special_tokens=False,
+    history = "\n".join(
+        [
+            f"User: {x['user']}\nSearch: {x['search']}"
+            for x in session["last_web_context"][-5:]
+        ]
     )
 
-    if len(tokens) <= max_tokens:
-        return text
+    prompt = f"""
+Entity:
+{session["last_entity"]}
+Recent conversation:
+{history}
+User follow-up:
+{query}
+Rewrite the follow-up as a standalone web search query.
+Return only the search query.
+""".strip()
 
-    return tokenizer.decode(
-        tokens[:max_tokens],
-        skip_special_tokens=True,
+    return execute_llm_generation(
+        prompt,
+        max_new_tokens=128
+    ).split("\n")[0].strip()
+
+
+# ============================================================
+# WEB SEARCH DETECTION
+# ============================================================
+
+def should_trigger_web_search(
+    q: str,
+    session: dict
+) -> bool:
+
+    q = q.lower()
+
+    search_triggers = [
+        "who",
+        "what",
+        "when",
+        "where",
+        "why",
+        "how",
+        "founder",
+        "ceo",
+        "company",
+        "price",
+        "stock",
+        "news",
+        "latest",
+        "today",
+        "current",
+        "recent",
+        "update",
+        "code",
+        "python",
+        "html",
+        "javascript",
+        "documentation",
+        "release",
+        "version"
+    ]
+
+    if any(
+        trigger in q
+        for trigger in search_triggers
+    ):
+        return True
+
+    return is_followup(
+        q,
+        session
     )
 
 
 # ============================================================
-# WEB SEARCH
+# DUCKDUCKGO
 # ============================================================
 
 def isolated_blocking_ddg(
-    query_string: str,
+    query_string: str
 ) -> list:
 
     try:
@@ -1535,44 +1399,45 @@ def isolated_blocking_ddg(
 
             results = ddgs.text(
                 query_string,
-                max_results=MAX_WEB_RESULTS,
+                max_results=5
             )
 
             if results:
 
-                urls = []
-
-                for result in results:
-
-                    href = result.get("href")
-
-                    if href:
-                        urls.append(href)
-
-                return list(
-                    dict.fromkeys(urls)
-                )
+                return [
+                    r["href"]
+                    for r in results
+                    if "href" in r
+                ]
 
     except Exception as e:
 
         logger.error(
-            "DuckDuckGo search failed: %s",
-            e,
+            f"Official DuckDuckGo Search failed: {e}"
         )
 
     return []
 
 
 async def search_web_async(
-    query: str,
+    query: str
 ) -> list:
 
     urls = await asyncio.to_thread(
         isolated_blocking_ddg,
-        query,
+        query
     )
 
-    return urls[:MAX_WEB_RESULTS]
+    if not urls:
+
+        urls.append(
+            "https://en.wikipedia.org/wiki/"
+            + query.replace(" ", "_")
+        )
+
+    return list(
+        dict.fromkeys(urls)
+    )[:5]
 
 
 # ============================================================
@@ -1581,45 +1446,36 @@ async def search_web_async(
 
 async def scrape_target_url(
     client,
-    url: str,
+    url: str
 ):
 
     try:
 
-        response = await client.get(
+        r = await client.get(
             url,
-            timeout=12.0,
+            timeout=10.0
         )
 
-        if response.status_code != 200:
+        if r.status_code != 200:
 
             logger.warning(
-                "HTTP %s: %s",
-                response.status_code,
-                url,
+                f"HTTP {r.status_code}: {url}"
             )
 
             return None
 
-        html = response.text
-
         text = None
 
         try:
 
             text = extract(
-                html,
-                include_comments=False,
-                include_tables=True,
-                favor_precision=True,
+                r.text
             )
 
         except Exception as e:
 
             logger.warning(
-                "Trafilatura failed for %s: %s",
-                url,
-                e,
+                f"Trafilatura failed for {url}: {e}"
             )
 
         if not text:
@@ -1627,31 +1483,447 @@ async def scrape_target_url(
             try:
 
                 soup = BeautifulSoup(
-                    html,
-                    "html.parser",
+                    r.text,
+                    "html.parser"
                 )
 
-                for tag in soup(
-                    [
-                        "script",
-                        "style",
-                        "noscript",
-                        "nav",
-                        "footer",
-                        "header",
-                    ]
-                ):
-                    tag.decompose()
-
                 text = soup.get_text(
                     separator=" ",
-                    strip=True,
+                    strip=True
                 )
 
             except Exception as e:
 
-                logger.warning(
-                    "BeautifulSoup failed for %s: %s",
-                    url,
-                    e,
-                )
+                logger.error(
+                    f"BeautifulSoup failed for {url}: {e}"
+                )
+
+                return None
+
+        if not text or len(text.split()) < 20:
+            return None
+
+        return {
+            "url": url,
+            "domain": urlparse(url).netloc,
+            "text": text[:2500]
+        }
+
+    except Exception as e:
+
+        logger.exception(
+            f"Scraping error for {url}: {e}"
+        )
+
+        return None
+
+
+# ============================================================
+# WEB CONTEXT PIPELINE
+# ============================================================
+
+async def build_context_pipeline(
+    query: str
+) -> tuple:
+
+    context_blocks = []
+    extraction_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,image/avif,"
+            "image/webp,*/*;q=0.8",
+
+        "Accept-Language":
+            "en-US,en;q=0.9",
+
+        "Accept-Encoding":
+            "gzip, deflate, br",
+
+        "Connection":
+            "keep-alive",
+
+        "Upgrade-Insecure-Requests":
+            "1"
+    }
+
+    from curl_cffi.requests import AsyncSession
+
+    async with AsyncSession(
+        impersonate="chrome",
+        headers=headers
+    ) as client:
+
+        tasks = [
+            scrape_target_url(
+                client,
+                u
+            )
+            for u in target_urls
+        ]
+
+        scraped_results = await asyncio.gather(
+            *tasks
+        )
+
+    for result in scraped_results:
+
+        if result:
+
+            context_blocks.append(
+                f"[{result['domain']}] "
+                f"{result['text']}"
+            )
+
+            extraction_sources.append(
+                result["url"]
+            )
+
+    return (
+        "\n\n".join(context_blocks),
+        list(set(extraction_sources))
+    )
+
+
+# ============================================================
+# MAIN ORCHESTRATION
+# ============================================================
+
+async def process_ask_orchestration(
+    q: str,
+    session: dict
+) -> tuple:
+
+    use_web = should_trigger_web_search(
+        q,
+        session
+    )
+
+    search_query = q
+
+    if (
+        use_web
+        and is_followup(q, session)
+        and session["last_entity"]
+    ):
+
+        search_query = rewrite_followup_query(
+            q,
+            session
+        )
+
+    context = ""
+    sources = []
+
+    # --------------------------------------------------------
+    # WEB SEARCH
+    # --------------------------------------------------------
+
+    if use_web:
+
+        if not is_followup(q, session):
+
+            try:
+
+                session["last_entity"] = (
+                    run_topic_extraction(q)
+                )
+
+            except Exception:
+
+                session["last_entity"] = q
+
+        context, sources = (
+            await build_context_pipeline(
+                search_query
+            )
+        )
+
+        if len(context.strip()) < 150:
+
+            context, sources = (
+                await build_context_pipeline(
+                    search_query + " wikipedia"
+                )
+            )
+
+        session[
+            "last_web_context"
+        ].append(
+            {
+                "user": q,
+                "search": search_query
+            }
+        )
+
+        if len(
+            session["last_web_context"]
+        ) > 5:
+
+            session[
+                "last_web_context"
+            ].pop(0)
+
+        session[
+            "last_web_query"
+        ] = search_query
+
+    # --------------------------------------------------------
+    # RETRIEVE REASONING EXAMPLES
+    # --------------------------------------------------------
+
+    reasoning_context = format_reasoning_examples(
+        q,
+        top_k=engine_state.get(
+            "reasoning_examples",
+            4
+        )
+    )
+
+    # --------------------------------------------------------
+    # SYSTEM PROMPT
+    # --------------------------------------------------------
+
+    system_prompt = """
+You are Infinity GRM, a capable reasoning and coding assistant.
+Solve problems carefully rather than jumping to the first familiar
+algorithm.
+For difficult problems:
+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
+        }
+    ]
+
+    # --------------------------------------------------------
+    # REASONING EXAMPLES
+    # --------------------------------------------------------
+
+    if reasoning_context:
+
+        messages.append(
+            {
+                "role": "system",
+                "content":
+                    "RELEVANT REASONING EXAMPLES:\n\n"
+                    + reasoning_context
+            }
+        )
+
+    # --------------------------------------------------------
+    # WEB CONTEXT
+    # --------------------------------------------------------
+
+    if use_web:
+
+        messages.extend(
+            session["history"][-10:]
+        )
+
+        messages.append(
+            {
+                "role": "user",
+                "content":
+                    f"WEB CONTEXT:\n"
+                    f"{context}\n\n"
+                    f"QUESTION:\n"
+                    f"{q}"
+            }
+        )
+
+    else:
+
+        messages.extend(
+            session["history"][-8:]
+        )
+
+        messages.append(
+            {
+                "role": "user",
+                "content": q
+            }
+        )
+
+    # --------------------------------------------------------
+    # CHAT TEMPLATE
+    # --------------------------------------------------------
+
+    compiled_prompt = (
+        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
+    )
+
+    session[
+        "last_response"
+    ] = response_string
+
+    update_history_buffer(
+        session,
+        "user",
+        q
+    )
+
+    update_history_buffer(
+        session,
+        "assistant",
+        response_string
+    )
+
+    return (
+        response_string,
+        sources
+    )
+
+
+# ============================================================
+# API ENDPOINTS
+# ============================================================
+
+@app.post("/query")
+async def chat_endpoint(
+    request: ChatRequest
+):
+
+    try:
+
+        session = fetch_or_create_session(
+            request.session_id
+        )
+
+        answer, sources = (
+            await process_ask_orchestration(
+                request.message,
+                session
+            )
+        )
+
+        save_session_to_redis(
+            request.session_id,
+            session
+        )
+
+        return {
+            "response": answer,
+            "sources": sources
+        }
+
+    except Exception as e:
+
+        logger.exception(
+            "Critical exception inside chat runtime pipeline"
+        )
+
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+        )
+
+
+@app.get("/health")
+async def validation_heartbeat():
+
+    return {
+        "status": "healthy",
+        "gpu_acceleration_active":
+            torch.cuda.is_available(),
+        "reasoning_examples":
+            len(REASONING_EXAMPLES)
+    }
+
+
+# ============================================================
+# STATIC FILES
+# ============================================================
+
+if not os.path.exists("static"):
+    os.makedirs("static")
+
+
+app.mount(
+    "/static",
+    StaticFiles(directory="static"),
+    name="static"
+)
+
+
+@app.get("/")
+async def home_route_processor():
+
+    return {
+        "message":
+            "Infinity GRM Engine Core is active.",
+        "reasoning_examples":
+            len(REASONING_EXAMPLES)
+    }
+
+
+# ============================================================
+# HUGGING FACE PORT
+# ============================================================
+
+if __name__ == "__main__":
+
+    port = int(
+        os.getenv(
+            "PORT",
+            7860
+        )
+    )
+
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=port
+    )