| import os |
| import json |
| import io |
| import re |
| import sys |
| import subprocess |
| import uuid |
| import logging |
| from contextlib import redirect_stdout |
| from fastapi import FastAPI, Request |
| from vllm import AsyncLLMEngine, AsyncEngineArgs, SamplingParams |
| from vllm.lora.request import LoRARequest |
|
|
| logging.basicConfig(level=logging.INFO) |
| logger = logging.getLogger(__name__) |
|
|
| |
| MODEL_PATH = os.getenv("MODEL_PATH", "Qwen/Qwen2.5-Coder-7B-Instruct") |
| LOGIC_LORA_PATH = os.getenv("LOGIC_LORA_PATH", "/app/models/logic_lora") |
| PHYSICS_LORA_PATH = os.getenv("PHYSICS_LORA_PATH", "/app/models/physics_lora") |
|
|
| app = FastAPI(title="EXACT 2026 AI Solver API", description="Multi-LoRA Inference Server for EXACT 2026") |
|
|
| logger.info(f"Loading Base Model: {MODEL_PATH}") |
| |
| engine_args = AsyncEngineArgs( |
| model=MODEL_PATH, |
| enable_lora=True, |
| max_loras=2, |
| max_lora_rank=64, |
| trust_remote_code=True, |
| gpu_memory_utilization=0.9 |
| ) |
| engine = AsyncLLMEngine.from_engine_args(engine_args) |
|
|
| |
| logger.info("Registering LoRA Adapters...") |
| try: |
| logic_lora = LoRARequest("logic", 1, LOGIC_LORA_PATH) |
| except Exception as e: |
| logger.warning(f"Could not load logic lora from {LOGIC_LORA_PATH}: {e}") |
| logic_lora = None |
|
|
| try: |
| physics_lora = LoRARequest("physics", 2, PHYSICS_LORA_PATH) |
| except Exception as e: |
| logger.warning(f"Could not load physics lora from {PHYSICS_LORA_PATH}: {e}") |
| physics_lora = None |
|
|
| |
| LOGIC_SYS = "You are an expert logical reasoning AI assistant. You solve logic puzzles and educational queries using Z3 Theorem Prover.\nAlways follow this strict format:\n1. Wrap your natural language reasoning inside <thought>...</thought> tags.\n2. In your thought, explicitly identify the required premises and apply logical rules.\n3. Write the Z3 Python code in a ```python ... ``` block.\n4. You MUST use the pre-defined helper functions `check_property(solver, property)` for Yes/No/Uncertain queries, and `check_mcq(solver, options_dict)` for multiple-choice queries. Do not define these functions yourself." |
| PHYSICS_SYS = "You are an expert AI physics tutor and programmer. You will be provided with a physics problem.\nYour task is to carefully analyze the problem and solve it step-by-step.\nFirst, explain your reasoning process wrapped within <reasoning> and </reasoning> tags.\nAfter your reasoning, provide a python script using the `sympy` library to calculate the exact final numerical answer.\nYour python code must print the final result in the format: print(f\"Answer: {float(result):.6g}\")." |
|
|
| |
| def extract_python_code(text): |
| if "```python" in text: |
| return text.split("```python")[1].split("```")[0].strip() |
| elif "```" in text: |
| return text.split("```")[1].split("```")[0].strip() |
| return "" |
|
|
| def execute_logic_code(code_str): |
| def fix_parentheses(code): |
| open_chars = "([{" |
| close_chars = ")]}" |
| mapping = {')': '(', ']': '[', '}': '{'} |
| chars = list(code) |
| stack = [] |
| in_string = False |
| string_char = None |
| escape = False |
| |
| for i, c in enumerate(chars): |
| if escape: |
| escape = False |
| continue |
| if c == '\\\\': |
| escape = True |
| continue |
| if c in ["'", '"']: |
| if not in_string: |
| in_string = True |
| string_char = c |
| elif string_char == c: |
| in_string = False |
| continue |
| if in_string: |
| continue |
| |
| if c in open_chars: |
| stack.append((c, i)) |
| elif c in close_chars: |
| expected_open = mapping[c] |
| match_idx = -1 |
| for idx in range(len(stack) - 1, -1, -1): |
| if stack[idx][0] == expected_open: |
| match_idx = idx |
| break |
| if match_idx != -1: |
| stack = stack[:match_idx] |
| else: |
| chars[i] = "" |
| |
| suffix = [] |
| reverse_mapping = {'(': ')', '[': ']', '{': '}'} |
| for c, _ in reversed(stack): |
| suffix.append(reverse_mapping[c]) |
| |
| return "".join(chars) + "".join(suffix) |
|
|
| code_str = fix_parentheses(code_str) |
| code_str = re.sub(r'([A-Za-z0-9_]+)\\s*>>\\s*([A-Za-z0-9_]+)', r'Implies(\\1, \\2)', code_str) |
| |
| env_code = """ |
| import z3 |
| from z3 import * |
| |
| def check_property(solver, prop): |
| solver.push() |
| solver.add(z3.Not(prop)) |
| is_always_true = (solver.check() == z3.unsat) |
| solver.pop() |
| solver.push() |
| solver.add(prop) |
| is_always_false = (solver.check() == z3.unsat) |
| solver.pop() |
| if is_always_true: |
| return 'Yes' |
| elif is_always_false: |
| return 'No' |
| else: |
| return 'Unknown' |
| |
| def check_mcq(solver, options_dict): |
| yes_opts = [] |
| for label, prop in options_dict.items(): |
| solver.push() |
| solver.add(z3.Not(prop)) |
| is_always_true = (solver.check() == z3.unsat) |
| solver.pop() |
| if is_always_true: |
| yes_opts.append(label) |
| if len(yes_opts) == 1: |
| return yes_opts[0] |
| no_opts = [] |
| for label, prop in options_dict.items(): |
| solver.push() |
| solver.add(prop) |
| is_always_false = (solver.check() == z3.unsat) |
| solver.pop() |
| if is_always_false: |
| no_opts.append(label) |
| if len(yes_opts) == 0 and len(no_opts) == 1: |
| return no_opts[0] |
| if len(yes_opts) > 1: |
| return yes_opts[0] |
| return 'Unknown' |
| """ + "\\n" + code_str |
|
|
| try: |
| res = subprocess.run([sys.executable, "-c", env_code], capture_output=True, text=True, timeout=10) |
| output = res.stdout.strip() |
| m = re.search(r'Answer:\\s*(.*)', output, re.IGNORECASE) |
| ans = m.group(1).strip() if m else "Error/Unknown" |
| return ans |
| except Exception as e: |
| return "Error" |
|
|
| def execute_physics_code(code_str): |
| local_scope = {} |
| out = '' |
| try: |
| f_io = io.StringIO() |
| with redirect_stdout(f_io): |
| exec(code_str, globals(), local_scope) |
| out = f_io.getvalue() |
| except Exception as e: |
| return "Error" |
| |
| match = re.search(r'Answer:\\s*(.+)', out) |
| if match: |
| return match.group(1).strip() |
| return "Error" |
|
|
| |
| @app.post("/v1/solve") |
| async def solve(request: Request): |
| data = await request.json() |
| req_id = data.get("id", str(uuid.uuid4())) |
| |
| is_logic = "premises-NL" in data |
| |
| if is_logic: |
| lora_req = logic_lora |
| user_prompt = "[Premises (Natural Language)]\\n" |
| for i, p in enumerate(data.get("premises-NL", [])): |
| user_prompt += f"{i+1}. {p}\\n" |
| user_prompt += "\\n[Question]\\n" + data.get("questions", [""])[0] |
| |
| full_prompt = f"<|im_start|>system\n{LOGIC_SYS}<|im_end|>\n<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n" |
| else: |
| lora_req = physics_lora |
| user_prompt = data.get("question", "") |
| |
| full_prompt = f"<|im_start|>system\n{PHYSICS_SYS}<|im_end|>\n<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n" |
|
|
| |
| sampling_params = SamplingParams(temperature=0.1, max_tokens=1500) |
| |
| |
| results_generator = engine.generate(full_prompt, sampling_params, req_id, lora_request=lora_req) |
| |
| final_output = None |
| async for request_output in results_generator: |
| final_output = request_output |
| |
| text_out = final_output.outputs[0].text |
| code = extract_python_code(text_out) |
| |
| if is_logic: |
| predicted_answer = execute_logic_code(code) if code else "Error" |
| else: |
| predicted_answer = execute_physics_code(code) if code else "Error" |
| |
| return { |
| "id": req_id, |
| "type": "logic" if is_logic else "physics", |
| "predicted_answer": predicted_answer, |
| "generated_code": code, |
| "raw_model_output": text_out |
| } |
|
|
| if __name__ == "__main__": |
| import uvicorn |
| uvicorn.run(app, host="0.0.0.0", port=8000) |
|
|
