Education, Legal & Creative Industries

# implement socratic_tutor
# Key operations: results display, API interaction
from openai import OpenAI

client = OpenAI()

def socratic_tutor(subject: str, student_question: str, student_level: str) -> str:
 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": f"""You are a Socratic tutor for {subject}.
Student level: {student_level}
NEVER give direct answers. Instead:
1. Acknowledge what the student understands correctly
2. Ask a guiding question that leads toward the answer
3. If they are stuck, break the problem into smaller steps
4. Celebrate progress and correct misconceptions gently
5. Adapt language complexity to the student's level"""},
 {"role": "user", "content": student_question},
 ],
 )
 return response.choices[0].message.content

reply = socratic_tutor(
 subject="calculus",
 student_question="I don't understand why the derivative of x^2 is 2x",
 student_level="high school",
)
print(reply)

# implement analyze_contract
# Key operations: attention mechanism, API interaction
from openai import OpenAI
import json

client = OpenAI()

def analyze_contract(contract_text: str) -> dict:
 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": """Analyze this contract and extract:
- parties (names and roles)
- key_dates (effective, termination, renewal)
- financial_terms (amounts, payment schedule, penalties)
- obligations (each party's key obligations)
- risk_clauses (limitation of liability, indemnification, IP)
- unusual_terms (anything atypical that needs attention)
Return structured JSON. Flag items requiring legal review."""},
 {"role": "user", "content": contract_text},
 ],
 response_format={"type": "json_object"},
 )
 return json.loads(response.choices[0].message.content)

# Creative writing assistant with style control
response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": """You are a creative writing assistant.
Help brainstorm, outline, and draft fiction. Match the user's
specified tone and style. Offer alternatives when generating
content. Never produce a single 'correct' version; always
provide options for the author to choose from."""},
 {"role": "user", "content": """I'm writing a mystery novel set in a
1920s speakeasy. I need three possible opening scenes that
establish atmosphere and introduce the detective protagonist.
Tone: noir, atmospheric, slightly sardonic."""},
 ],
)
print(response.choices[0].message.content)

# Style transfer: convert between registers, tones, and reading levels
from openai import OpenAI

client = OpenAI()

def transfer_style(
 text: str,
 source_style: str,
 target_style: str,
 context: str = "",
) -> str:
 """Rewrite text from one style to another, preserving meaning."""
 system_prompt = f"""You are an expert editor specializing in style adaptation.
Rewrite the given text from {source_style} to {target_style}.

Rules:
1. Preserve ALL factual content and key details
2. Adjust vocabulary, sentence structure, and tone
3. Do NOT add information that is not in the original
4. Match the target audience's reading level
{f'Additional context: {context}' if context else ''}"""

 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": system_prompt},
 {"role": "user", "content": text},
 ],
 temperature=0.4,
 )
 return response.choices[0].message.content

# Example 1: Technical to accessible
technical = """The patient presents with acute myocardial infarction
characterized by ST-segment elevation in leads V1-V4, consistent
with anterior wall involvement. Troponin I levels are elevated
at 15.2 ng/mL. Emergent percutaneous coronary intervention is
indicated."""

accessible = transfer_style(
 text=technical,
 source_style="clinical medical terminology",
 target_style="plain language for a patient and their family",
 context="Target reading level: 8th grade",
)
print("Simplified:\n", accessible)

# Example 2: Formal to conversational brand voice
formal = """We are pleased to announce the availability of our latest
software release, which incorporates numerous enhancements to
system performance and user interface responsiveness."""

casual = transfer_style(
 text=formal,
 source_style="formal corporate announcement",
 target_style="friendly, conversational brand voice (like Slack or Notion)",
)
print("Brand voice:\n", casual)

# LLM-based grammatical error correction with explanations
from openai import OpenAI
import json

client = OpenAI()

def correct_grammar(text: str, explain: bool = True) -> dict:
 """Correct grammatical errors with optional explanations."""
 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": """You are a grammar correction assistant.
Fix grammatical errors in the given text. Return JSON with:
- "corrected": the corrected text
- "changes": a list of objects, each with "original", "corrected", and "rule"
 (the grammar rule that applies, e.g., "subject-verb agreement")

Rules:
1. Fix grammar, spelling, and punctuation errors
2. Do NOT change style, tone, or word choice unless it is a clear error
3. Preserve the author's voice and intent
4. If the text is already correct, return it unchanged with an empty changes list"""},
 {"role": "user", "content": text},
 ],
 response_format={"type": "json_object"},
 temperature=0.0,
 )
 return json.loads(response.choices[0].message.content)

# Example: correct a paragraph with multiple error types
text = """Their going to the store tommorrow, but neither the manager
nor the employees is aware of the scheduile change. The report,
along with its appendicies, were submitted late."""

result = correct_grammar(text)
print("Corrected:", result["corrected"])
for change in result["changes"]:
 print(f" {change['original']} -> {change['corrected']}")
 print(f" Rule: {change['rule']}")

# Data-to-text generation: convert a statistics table to narrative text
# Serializes structured data as Markdown, then generates a narrative
from openai import OpenAI

client = OpenAI()

def stats_to_narrative(
 data: list[dict],
 context: str,
 audience: str = "general",
 tone: str = "professional"
) -> str:
 """Convert structured data into a natural language narrative."""
 # Step 1: serialize data as a Markdown table
 if not data:
 return "No data available."
 headers = list(data[0].keys())
 md_table = "| " + " | ".join(headers) + " |\n"
 md_table += "| " + " | ".join(["---"] * len(headers)) + " |\n"
 for row in data:
 md_table += "| " + " | ".join(str(row[h]) for h in headers) + " |\n"

 # Step 2: generate narrative from serialized data
 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": f"""You are a data analyst who
writes clear {tone} narratives for a {audience} audience. Convert the
provided data table into a coherent paragraph that:
1. States the key finding or trend first
2. Supports it with specific numbers from the data
3. Notes any notable outliers or changes
4. Keeps the narrative concise (3 to 5 sentences)
NEVER fabricate numbers. Only reference values present in the data."""},
 {"role": "user", "content": f"Context: {context}\n\n{md_table}"}
 ],
 temperature=0.3
 )
 return response.choices[0].message.content

# Example: quarterly sales data
sales_data = [
 {"Quarter": "Q1 2024", "Revenue ($M)": 142, "Growth (%)": 8.2,
 "Top Region": "North America"},
 {"Quarter": "Q2 2024", "Revenue ($M)": 158, "Growth (%)": 11.3,
 "Top Region": "Europe"},
 {"Quarter": "Q3 2024", "Revenue ($M)": 151, "Growth (%)": 6.4,
 "Top Region": "North America"},
 {"Quarter": "Q4 2024", "Revenue ($M)": 189, "Growth (%)": 25.2,
 "Top Region": "Asia Pacific"},
]

narrative = stats_to_narrative(
 sales_data,
 context="Annual revenue performance for CloudTech Inc.",
 audience="executive leadership",
 tone="concise and data-driven"
)
print(narrative)