0. Čo je AI agent?

pip install anthropic

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-...")  # alebo cez env: ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Vysvetli mi čo je Kubernetes v dvoch vetách."}
    ]
)

print(message.content[0].text)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="Si skúsený DevOps inžinier. Odpovedáš stručne a technicky presne. Vždy uvádzaš konkrétne príkazy.",
    messages=[
        {"role": "user", "content": "Ako zistím využitie pamäte v Kubernetes pode?"}
    ]
)

print(message.content[0].text)

import anthropic
import json

client = anthropic.Anthropic()

# 1. Definovanie nástrojov
tools = [
    {
        "name": "get_weather",
        "description": "Vráti aktuálne počasie pre dané mesto",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Názov mesta"}
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate",
        "description": "Vypočíta matematický výraz",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Matematický výraz, napr. '2 + 2 * 3'"}
            },
            "required": ["expression"]
        }
    }
]

# 2. Implementácia nástrojov
def get_weather(city: str) -> str:
    # V reálnom projekte by si zavolal weather API
    fake_data = {
        "Bratislava": "12°C, oblačno",
        "Košice": "8°C, dážď",
        "Praha": "10°C, slnečno"
    }
    return fake_data.get(city, f"Dáta pre {city} nie sú dostupné")

def calculate(expression: str) -> str:
    try:
        result = eval(expression)  # Pozor: v produkcii použi bezpečný parser!
        return str(result)
    except Exception as e:
        return f"Chyba: {e}"

# 3. Spúšťanie agenta
def run_agent(user_message: str):
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )

        # Koniec — agent odpovedal
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, 'text'):
                    print(f"Agent: {block.text}")
            break

        # Agent chce zavolať nástroj
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            tool_results = []

            for block in response.content:
                if block.type == "tool_use":
                    print(f"  → Volám nástroj: {block.name}({block.input})")

                    if block.name == "get_weather":
                        result = get_weather(**block.input)
                    elif block.name == "calculate":
                        result = calculate(**block.input)
                    else:
                        result = "Neznámy nástroj"

                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })

            messages.append({"role": "user", "content": tool_results})

# Testujeme
run_agent("Aké je počasie v Bratislave a koľko je 15 * 7 + 3?")

pip install openai

from openai import OpenAI

client = OpenAI(api_key="sk-proj-...")  # alebo cez OPENAI_API_KEY env

# Základné volanie — Responses API
response = client.responses.create(
    model="gpt-4o",
    input="Čo je to Kubernetes?"
)

print(response.output_text)

import json
from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Vráti počasie pre mesto",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }
]

response = client.responses.create(
    model="gpt-4o",
    tools=tools,
    input="Aké je počasie v Košiciach?"
)

# Spracovanie výstupu
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)
        print(f"Volám: {item.name}({args})")
        # Tu by si spustil svoju funkciu a výsledok poslal späť

# Spustenie n8n s Docker
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD=heslo123 \
  n8nio/n8n

# Otvor v browseri: http://localhost:5678

npm install -g n8n
n8n start

# Cez npm
npm install -g flowise
npx flowise start

# Alebo Docker
docker run -d \
  -p 3000:3000 \
  -v ~/.flowise:/root/.flowise \
  flowiseai/flowise

# Otvor: http://localhost:3000

pip install langgraph langchain-anthropic

from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

# 1. Definícia nástrojov s dekorátorom @tool
@tool
def get_weather(city: str) -> str:
    """Vráti aktuálne počasie pre dané mesto."""
    data = {"Bratislava": "15°C, slnečno", "Košice": "10°C, oblačno"}
    return data.get(city, f"Dáta pre {city} nie sú dostupné")

@tool
def multiply(a: float, b: float) -> float:
    """Vynásobí dve čísla."""
    return a * b

# 2. Vytvorenie agenta (jednoduché!)
model = ChatAnthropic(model="claude-sonnet-4-6")
agent = create_react_agent(model, tools=[get_weather, multiply])

# 3. Spustenie
response = agent.invoke({
    "messages": [{"role": "user", "content": "Aké je počasie v Bratislave a koľko je 23 * 7?"}]
})

# Posledná správa je odpoveď agenta
print(response["messages"][-1].content)