0. What is an AI agent?

pip install anthropic

import anthropic

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

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain what Kubernetes is in two sentences."}
    ]
)

print(message.content[0].text)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="You are an experienced DevOps engineer. You answer concisely and with technical precision. Always provide specific commands.",
    messages=[
        {"role": "user", "content": "How do I check memory usage in a Kubernetes pod?"}
    ]
)

print(message.content[0].text)

import anthropic
import json

client = anthropic.Anthropic()

# 1. Define tools
tools = [
    {
        "name": "get_weather",
        "description": "Returns current weather for a given city",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate",
        "description": "Calculates a mathematical expression",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Mathematical expression, e.g. '2 + 2 * 3'"}
            },
            "required": ["expression"]
        }
    }
]

# 2. Implement tools
def get_weather(city: str) -> str:
    # In a real project you would call a weather API
    fake_data = {
        "Bratislava": "12°C, cloudy",
        "Kosice": "8°C, rain",
        "Prague": "10°C, sunny"
    }
    return fake_data.get(city, f"Data for {city} is not available")

def calculate(expression: str) -> str:
    try:
        result = eval(expression)  # Warning: use a safe parser in production!
        return str(result)
    except Exception as e:
        return f"Error: {e}"

# 3. Run the agent
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
        )

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

        # Agent wants to call a tool
        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"  → Calling tool: {block.name}({block.input})")

                    if block.name == "get_weather":
                        result = get_weather(**block.input)
                    elif block.name == "calculate":
                        result = calculate(**block.input)
                    else:
                        result = "Unknown tool"

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

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

# Test it
run_agent("What is the weather in Bratislava and what is 15 * 7 + 3?")

pip install openai

from openai import OpenAI

client = OpenAI(api_key="sk-proj-...")  # or via OPENAI_API_KEY env

# Basic call — Responses API
response = client.responses.create(
    model="gpt-4o",
    input="What is Kubernetes?"
)

print(response.output_text)

import json
from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Returns weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }
]

response = client.responses.create(
    model="gpt-4o",
    tools=tools,
    input="What is the weather in Kosice?"
)

# Process output
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)
        print(f"Calling: {item.name}({args})")
        # Here you would run your function and send the result back

# Start n8n with 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=password123 \
  n8nio/n8n

# Open in browser: http://localhost:5678

npm install -g n8n
n8n start

# Via npm
npm install -g flowise
npx flowise start

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

# Open: 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. Define tools with the @tool decorator
@tool
def get_weather(city: str) -> str:
    """Returns current weather for a given city."""
    data = {"Bratislava": "15°C, sunny", "Kosice": "10°C, cloudy"}
    return data.get(city, f"Data for {city} not available")

@tool
def multiply(a: float, b: float) -> float:
    """Multiplies two numbers."""
    return a * b

# 2. Create agent (simple!)
model = ChatAnthropic(model="claude-sonnet-4-6")
agent = create_react_agent(model, tools=[get_weather, multiply])

# 3. Run
response = agent.invoke({
    "messages": [{"role": "user", "content": "What is the weather in Bratislava and what is 23 * 7?"}]
})

# The last message is the agent's response
print(response["messages"][-1].content)