We are going to build a Socratic tutor agent that ingests a reading passage and guides a student through it with targeted questions instead of handing out answers. This pattern is useful for anyone building ed-tech tools, homework helpers, or corporate training bots. We will run it on Oxlo.ai so that long context windows and extended multi-turn sessions stay predictable.
What you'll need
You need Python 3.10 or newer installed locally. Install the OpenAI SDK with pip install openai. You also need an Oxlo.ai API key from https://portal.oxlo.ai. Oxlo.ai uses request-based pricing, so you pay one flat cost per API call regardless of how long the reading passage is or how many turns the conversation lasts. That matters in education, where a single session can include a full textbook chapter and twenty back-and-forth messages. See the latest plans at https://oxlo.ai/pricing.
Step 1: Set up the client and system prompt
The most important part of this build is the system prompt. A raw LLM will happily give away the answer, which defeats the purpose of tutoring. We need a strict persona that forces the model to ask exactly one question at a time and never reveal the solution directly. I use Llama 3.3 70B for this because it is a reliable general-purpose flagship that follows instruction boundaries well. Oxlo.ai hosts it with no cold starts, so the first request of a study session is just as fast as the tenth.
The prompt is intentionally rigid. In my testing, softer instructions like "try to ask questions" failed about thirty percent of the time. By enumerating six hard rules, the model stays in character even when the student begs for the answer. Because Oxlo.ai is fully OpenAI SDK compatible, the only change from a standard script is the base_url.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.oxlo.ai/v1",
api_key=os.environ.get("OXLO_API_KEY", "YOUR_OXLO_API_KEY"),
)
SYSTEM_PROMPT = """You are a Socratic tutor. Your goal is to help the student understand a reading passage through guided reasoning.
Rules:
1. Never give the answer directly.
2. Ask exactly one concise question per turn.
3. Wait for the student's response before proceeding.
4. If the student is stuck, offer a tiny hint, then ask another question.
5. Base every question on the reading passage provided at the start of the session.
6. Keep your tone neutral and encouraging.
Begin by asking an opening question about the passage."""Step 2: Stream the conversation loop
A tutor that makes the student wait for a full response feels broken, so I enable streaming. I also accumulate the assistant's reply into the messages list so the model retains context across the session. In a production app you would persist that list to Redis or a database keyed by session ID, but for this demo we keep it in memory.
The tutor_turn function is pure. It takes the current state and a new user message, and it returns the new state. That makes it trivial to unit test or to wrap behind an API. This is where Oxlo.ai's pricing model really matters for education. On token-based providers, every new turn resends the entire conversation history, which means costs climb as the session deepens. With Oxlo.ai, each turn is one flat request. A ten-turn deep dive into a difficult concept costs the same per turn as a single greeting, so you are not penalized for letting the student think out loud. That encourages longer, more effective tutoring sessions without a meter running in the background.
def tutor_turn(messages, user_message):
messages.append({"role": "user", "content": user_message})
response = client.chat.completions.create(
model="llama-3.3-70b",
messages=messages,
stream=True,
)
reply = ""
for chunk in response:
if chunk.choices[0].delta.content:
text = chunk.choices[0].delta.content
reply += text
print(text, end="", flush=True)
print()
messages.append({"role": "assistant", "content": reply})
return messagesStep 3: Prime the session with a passage
Real educational content is long. A reading comprehension worksheet, a textbook chapter, or a technical manual can easily run to thousands of words. You do not want to strip that down and lose nuance. I inject the full passage into the message history before the loop begins so the model can reference it on every turn. Because Oxlo.ai charges per request rather than per token, stuffing a long passage into the context does not inflate the cost. This makes it practical to give the model the entire source document, not just a summary.
You could load the passage from a PDF parser or a web scraper. Because Oxlo.ai does not meter input tokens, there is no need to aggressively truncate or chunk the text before sending it. Just pass the full string. I also insert an assistant acknowledgement message after the passage. That ensures the conversation alternates correctly between user and assistant roles, which avoids format errors when the history grows. If you are building a STEM tutor that needs heavier reasoning, you can swap the model string to deepseek-v3.2 or kimi-k2.6 without touching any other code. Both are exposed through the same Oxlo.ai endpoint.
def start_session(passage):
messages = [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": f"Here is the passage to discuss:\n\n{passage}"},
{"role": "assistant", "content": "Understood. I will guide you through it."},
]
return messagesStep 4: Wire the CLI loop
Now I connect the pieces. The main block defines a sample passage, initializes the history, and starts the interaction. I send an opening user message to trigger the tutor's first question, then loop until the student types exit. The opening message "Please start" is a simple trick to get the model talking without hardcoding the first question in Python. The system prompt already told it to begin, so it knows what to do.
In production, you would replace the input() call with an HTTP route and stream chunks over SSE or WebSocket. Oxlo.ai has no cold starts on popular models, so the first user of the day will not hit a spin-up delay. Everything is stateless on the server side. The conversation lives entirely in the local messages list, which means you can kill and restart the script without losing context as long as you serialize that list somewhere.
PASSAGE = """Photosynthesis is the process used by plants, algae, and certain bacteria to convert light energy into chemical energy. During photosynthesis, chlorophyll absorbs sunlight, which drives a reaction that splits water molecules and releases oxygen. The remaining hydrogen is combined with carbon dioxide to form glucose, a simple sugar that fuels the organism's activities."""
messages = start_session(PASSAGE)
# Trigger the opening question.
messages = tutor_turn(messages, "Please start.")
while True:
user_input = input("\nStudent: ").strip()
if user_input.lower() in {"exit", "quit"}:
break
messages = tutor_turn(messages, user_input)Run it
Save the script as tutor.py, export your OXLO_API_KEY, and run it. Here is what a short session looks like:
$ export OXLO_API_KEY=sk-... $ python tutor.py Tutor: According to the passage, what is the primary source of energy that drives photosynthesis? Student: The sun. Tutor: Correct, the passage mentions sunlight. Now, what specific molecule in the plant absorbs that sunlight energy? Student: I am not sure. Tutor: That is okay. The passage names a green pigment. What molecule could that be? Student: Chlorophyll. Tutor: Exactly. Once chlorophyll absorbs the light, what happens to the water molecules? Student: exit
Wrap-up
This agent gives you a foundation for any educational product that needs guided reasoning over long documents. Two concrete next steps come to mind. First, wrap the loop in a FastAPI endpoint and stream responses to a React frontend so students can use it in a browser. Second, add an evaluator agent that reads the final conversation transcript and emits a comprehension score. You can run that evaluator in a separate request to qwen-3-32b or deepseek-v3.2 using the same Oxlo.ai client setup. Because there are no cold starts, the evaluator responds immediately even if it is the first call of the hour. Either way, the cost stays flat per call, which keeps your tutoring budget predictable no matter how wordy your users get.
