Writing and Content

import requests

def generate(model, prompt):
    r = requests.post("http://localhost:11434/api/generate", json={
        "model": model, "prompt": prompt, "stream": False
    })
    return r.json()["response"]

for task, model in [
    ("Write a tweet about AI", "qwen3.5:4b"),
    ("Write a technical article about RAG", "qwen3.5:9b"),
]:
    print(f"Using {model}...")

def reflection_article(topic):
    r1 = requests.post("http://localhost:11434/api/chat", json={
        "model": "qwen3.5:9b",
        "messages": [{"role": "user", "content": f"Write an article about: {topic}"}]
    })
    draft = r1.json()["message"]["content"]

    r2 = requests.post("http://localhost:11434/api/chat", json={
        "model": "qwen3.5:4b",
        "messages": [
            {"role": "system", "content": "You are a strict editor. Find issues."},
            {"role": "user", "content": draft}
        ]
    })
    feedback = r2.json()["message"]["content"]

    r3 = requests.post("http://localhost:11434/api/chat", json={
        "model": "qwen3.5:9b",
        "messages": [
            {"role": "system", "content": "Improve based on the feedback."},
            {"role": "user", "content": f"Draft:\n{draft}\n\nFeedback:\n{feedback}\n\nImproved:"}
        ]
    })
    return r3.json()["message"]["content"]

import requests

OLLAMA = "http://localhost:11434/api/chat"

def draft(text: str) -> str:
    """Quick draft."""
    r = requests.post(OLLAMA, json={
        "model": "qwen3.5:4b",
        "messages": [{"role": "user", "content": text}],
        "stream": False
    })
    return r.json()["message"]["content"]

def review(text: str) -> str:
    """Critical review."""
    r = requests.post(OLLAMA, json={
        "model": "qwen3.5:9b",
        "messages": [
            {"role": "system", "content": (
                "You are an editor. Find errors, inaccuracies, weak spots in the text. "
                "Check: facts, grammar, style, structure."
            )},
            {"role": "user", "content": text}
        ],
        "stream": False
    })
    return r.json()["message"]["content"]

def improve(text: str, critique: str) -> str:
    """Improve based on critique."""
    r = requests.post(OLLAMA, json={
        "model": "qwen3.5:9b",
        "messages": [
            {"role": "system", "content": "Improve the text based on the critique. Return only the final version."},
            {"role": "user", "content": f"Original:\n{text}\n\nCritique:\n{critique}\n\nImproved text:"}
        ],
        "stream": False
    })
    return r.json()["message"]["content"]

# Full pipeline
def write_with_reflection(topic: str) -> str:
    """Writes text with self-review."""
    print("  ✏️ Draft...")
    raw = draft(f"Write a short article on: {topic}")
    print("  🔍 Review...")
    critique = review(raw)
    print("  ✨ Final version...")
    final = improve(raw, critique)
    return final

# Example
article = write_with_reflection("Advantages of local AI models")
print(article)

#!/usr/bin/env python3
"""content_generator.py — mass text generation through Ollama."""

import requests
import csv
from pathlib import Path

OLLAMA = "http://localhost:11434/api/chat"

def generate(topic: str, tone: str = "neutral") -> str:
    """Generates text by topic with given tone."""
    
    tones = {
        "neutral": "Write an informative text.",
        "professional": "Write a business text. Use professional vocabulary.",
        "friendly": "Write a friendly, conversational text.",
        "persuasive": "Write a persuasive text with a call to action."
    }
    
    response = requests.post(OLLAMA, json={
        "model": "qwen3.5:4b",
        "messages": [
            {"role": "system", "content": tones.get(tone, tones["neutral"])},
            {"role": "user", "content": f"Topic: {topic}"}
        ],
        "stream": False
    })
    return response.json()["message"]["content"]


# Generate from CSV file
def generate_from_csv(csv_path: str, output_dir: str = "output"):
    """Generates texts for each CSV row."""
    
    Path(output_dir).mkdir(exist_ok=True)
    
    with open(csv_path) as f:
        reader = csv.DictReader(f)
        for row in reader:
            text = generate(row["topic"], row.get("tone", "neutral"))
            
            filename = row.get("filename", f"{row['topic'][:30]}.md")
            filepath = Path(output_dir) / filename
            filepath.write_text(text)
            print(f"  ✓ {filename}")


if __name__ == "__main__":
    # Example: mass generate descriptions
    topics = [
        {"topic": "What is RAG in the context of LLM", "tone": "professional"},
        {"topic": "How to choose a model for coding", "tone": "friendly"},
        {"topic": "Advantages of local AI over cloud", "tone": "persuasive"},
    ]
    
    for item in topics:
        text = generate(item["topic"], item["tone"])
        print(f"\n📄 {item['topic']}")
        print(text[:200] + "...")

topics = ["What is RAG", "Local LLM setup", "AI agents explained"]
for topic in topics:
    article = reflection_article(topic)
    filename = topic.lower().replace(" ", "_") + ".md"
    with open(filename, "w") as f:
        f.write(f"# {topic}\n\n{article}")