Multi-agent workflows

from crewai import Agent, Task, Crew, LLM

coder_llm = LLM(
    model="openai/qwen3.6:35b-a3b",
    base_url="https://api.staik.se/v1",
    api_key="sk-st-your-key",
)

reviewer_llm = LLM(
    model="openai/gemma4:31b",
    base_url="https://api.staik.se/v1",
    api_key="sk-st-your-key",
)

coder = Agent(
    role="Developer",
    goal="Write clean, working Python code",
    backstory="Senior Python developer with focus on readability.",
    llm=coder_llm,
)

reviewer = Agent(
    role="Code Reviewer",
    goal="Review code for bugs, style and correctness",
    backstory="Meticulous code reviewer who catches edge cases.",
    llm=reviewer_llm,
)

code_task = Task(
    description="Skriv en Python-funktion som validerar e-postadresser med regex.",
    expected_output="En korrekt Python-funktion med docstring.",
    agent=coder,
)

review_task = Task(
    description="Granska koden. Kontrollera edge cases, säkerhet och läsbarhet. Ge konkret feedback.",
    expected_output="Godkänt eller lista med förbättringsförslag.",
    agent=reviewer,
)

crew = Crew(agents=[coder, reviewer], tasks=[code_task, review_task])
result = crew.kickoff()
print(result)

from crewai import Agent, Task, Crew, Process, LLM

def staik_llm(model: str) -> LLM:
    return LLM(
        model=f"openai/{model}",
        base_url="https://api.staik.se/v1",
        api_key="sk-st-your-key",
    )

orchestrator = Agent(
    role="Project Manager",
    goal="Break down tasks and coordinate the team",
    llm=staik_llm("gemma4:31b"),
)

coder = Agent(
    role="Developer",
    goal="Implement features based on specifications",
    llm=staik_llm("qwen3.6:35b-a3b"),
)

tester = Agent(
    role="QA Engineer",
    goal="Write comprehensive test cases",
    llm=staik_llm("qwen3.5:9b"),
)

task = Task(
    description="Bygg en REST API-endpoint för användarregistrering med validering och tester.",
    expected_output="Komplett implementation med tester.",
    agent=orchestrator,
)

crew = Crew(
    agents=[orchestrator, coder, tester],
    tasks=[task],
    process=Process.hierarchical,
    manager_agent=orchestrator,
)
result = crew.kickoff()
print(result)

from openai import OpenAI

client = OpenAI(
    base_url="https://api.staik.se/v1",
    api_key="sk-st-your-key",
)

def generate_and_review(task: str) -> str:
    # Steg 1: Agenten genererar ett förslag
    proposal = client.chat.completions.create(
        model="qwen3.6:35b-a3b",
        messages=[
            {"role": "system", "content": "Du är en senior utvecklare. Generera ett förslag."},
            {"role": "user", "content": task},
        ],
    ).choices[0].message.content

    print(f"\n--- FÖRSLAG ---\n{proposal}\n")

    # Steg 2: Människa granskar
    feedback = input("Godkänn (enter) eller ge feedback: ")

    if not feedback:
        return proposal

    # Steg 3: Agenten reviderar baserat på feedback
    revised = client.chat.completions.create(
        model="qwen3.6:35b-a3b",
        messages=[
            {"role": "system", "content": "Revidera ditt förslag baserat på feedbacken."},
            {"role": "user", "content": task},
            {"role": "assistant", "content": proposal},
            {"role": "user", "content": feedback},
        ],
    ).choices[0].message.content

    return revised

result = generate_and_review("Designa ett databasschema för en e-handelsapp.")
print(result)

from openai import OpenAI

client = OpenAI(
    base_url="https://api.staik.se/v1",
    api_key="sk-st-your-key",
)

def pipeline_step(model: str, system: str, content: str) -> str:
    return client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": content},
        ],
    ).choices[0].message.content

# Steg 1: Skriv teknisk dokumentation
draft = pipeline_step(
    "qwen3.6:35b-a3b",
    "Du är en teknisk skribent. Skriv tydlig dokumentation.",
    "Dokumentera hur man sätter upp en WebSocket-server i Python.",
)
print("Utkast klart")

# Steg 2: Granska språk och noggrannhet
reviewed = pipeline_step(
    "gemma4:31b",
    "Du är en redaktör. Förbättra text utan att ändra tekniskt innehåll.",
    draft,
)
print("Granskning klar")

# Steg 3: Översätt till svenska
translated = pipeline_step(
    "qwen3.5:9b",
    "Översätt till flytande svenska. Behåll kodexempel oförändrade.",
    reviewed,
)
print("Översättning klar")
print(translated)

from openai import OpenAI

client = OpenAI(
    base_url="https://api.staik.se/v1",
    api_key="sk-st-your-key",
)

response = client.chat.completions.create(
    model="gemma4:31b",
    messages=[
        {"role": "system", "content": "Du är en hjälpsam assistent."},
        {"role": "user", "content": "Förklara GDPR kort."}
    ],
    temperature=0.7,
    max_tokens=500,
)
print(response.choices[0].message.content)

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(
    model="gemma4:31b",
    base_url="https://api.staik.se/v1",
    api_key="sk-st-your-key",
)

response = llm.invoke([
    HumanMessage(content="Skriv en haiku om Stockholm")
])
print(response.content)

import { createOpenAI } from "@ai-sdk/openai";
import { generateText } from "ai";

const staik = createOpenAI({
  baseURL: "https://api.staik.se/v1",
  apiKey: "sk-st-your-key",
});

const { text } = await generateText({
  model: staik("gemma4:31b"),
  prompt: "Förklara GDPR kort.",
});
console.log(text);

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.staik.se/v1",
  apiKey: "sk-st-your-key",
});

const response = await client.chat.completions.create({
  model: "gemma4:31b",
  messages: [
    { role: "user", content: "Hello from Node.js!" }
  ],
});
console.log(response.choices[0].message.content);