Claude

# Przykład użycia Claude Opus 4.5 do złożonego refaktoringu
import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-5-20251101",
    max_tokens=8192,
    messages=[
        {
            "role": "user",
            "content": """Przeanalizuj poniższy kod i zaproponuj kompleksowy
            refaktoring z uwzględnieniem SOLID principles, design patterns
            i najlepszych praktyk TypeScript:

            [kod do analizy]"""
        }
    ]
)

print(message.content[0].text)

// Przykład integracji Claude Sonnet z aplikacją Next.js
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY!
})

export async function POST(request: Request) {
  const { message, conversationHistory } = await request.json()

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-5-20241022',
    max_tokens: 4096,
    system: `Jesteś pomocnym asystentem programistycznym.
             Odpowiadaj zawsze w języku polskim.`,
    messages: [
      ...conversationHistory,
      { role: 'user', content: message }
    ]
  })

  return Response.json({
    reply: response.content[0].text,
    usage: response.usage
  })
}

# Przykład batch processing z Claude Haiku
import anthropic
import asyncio

client = anthropic.Anthropic()

async def classify_support_ticket(ticket: str) -> dict:
    message = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=100,
        messages=[
            {
                "role": "user",
                "content": f"""Sklasyfikuj poniższy ticket supportu.
                Zwróć JSON z polami: category, priority, sentiment.

                Ticket: {ticket}"""
            }
        ]
    )
    return {"classification": message.content[0].text}

# Przetwarzanie wielu ticketów równolegle
async def process_tickets(tickets: list[str]):
    tasks = [classify_support_ticket(t) for t in tickets]
    return await asyncio.gather(*tasks)

# Instalacja SDK
pip install anthropic  # Python
npm install @anthropic-ai/sdk  # JavaScript/TypeScript

# Podstawowe wywołanie API w Pythonie
import anthropic

client = anthropic.Anthropic(
    api_key="your-api-key"  # Lub ustaw ANTHROPIC_API_KEY
)

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Wyjaśnij czym jest React w 3 zdaniach."}
    ]
)

print(message.content[0].text)

// Podstawowe wywołanie API w TypeScript
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
})

const message = await anthropic.messages.create({
  model: 'claude-sonnet-4-5-20241022',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Wyjaśnij czym jest React w 3 zdaniach.' }
  ]
})

console.log(message.content[0].text)

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    system="""Jesteś doświadczonym architektem oprogramowania z 15-letnim
    doświadczeniem. Specjalizujesz się w:
    - Projektowaniu systemów rozproszonych
    - Microservices i event-driven architecture
    - Performance optimization

    Odpowiadasz konkretnie, z przykładami kodu i diagramami ASCII
    gdzie to pomocne. Zawsze uwzględniasz trade-offs różnych rozwiązań.""",
    messages=[
        {"role": "user", "content": "Jak zaprojektować system notyfikacji dla 1M użytkowników?"}
    ]
)

import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

// Streaming w TypeScript
const stream = await anthropic.messages.stream({
  model: 'claude-sonnet-4-5-20241022',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Napisz tutorial o React Hooks' }
  ]
})

for await (const event of stream) {
  if (event.type === 'content_block_delta' &&
      event.delta.type === 'text_delta') {
    process.stdout.write(event.delta.text)
  }
}

# Streaming w Pythonie
with client.messages.stream(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Napisz tutorial o React Hooks"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

import base64

# Załaduj obraz
with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Co widzisz na tym zrzucie ekranu? Zidentyfikuj wszystkie elementy UI."
                }
            ]
        }
    ]
)

tools = [
    {
        "name": "get_weather",
        "description": "Pobiera aktualną pogodę dla podanego miasta",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nazwa miasta"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Jednostka temperatury"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "search_database",
        "description": "Wyszukuje w bazie danych produktów",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
                "max_results": {"type": "integer", "default": 10}
            },
            "required": ["query"]
        }
    }
]

message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "Jaka jest pogoda w Warszawie?"}
    ]
)

# Claude odpowie z tool_use jeśli zdecyduje użyć narzędzia
for block in message.content:
    if block.type == "tool_use":
        print(f"Tool: {block.name}")
        print(f"Input: {block.input}")

# Oznacz części promptu do cache'owania
message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Jesteś asystentem programistycznym...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": large_code_context,  # Duży kontekst kodu
                    "cache_control": {"type": "ephemeral"}
                },
                {
                    "type": "text",
                    "text": "Znajdź potencjalne błędy w tym kodzie."
                }
            ]
        }
    ]
)

# Utworzenie batch request
batch = client.batches.create(
    requests=[
        {
            "custom_id": "request-1",
            "params": {
                "model": "claude-sonnet-4-5-20241022",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Pytanie 1..."}
                ]
            }
        },
        {
            "custom_id": "request-2",
            "params": {
                "model": "claude-sonnet-4-5-20241022",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Pytanie 2..."}
                ]
            }
        }
    ]
)

# Sprawdzanie statusu
status = client.batches.retrieve(batch.id)
print(f"Status: {status.processing_status}")

# Pobieranie wyników gdy gotowe
if status.processing_status == "ended":
    results = client.batches.results(batch.id)
    for result in results:
        print(f"{result.custom_id}: {result.result.message.content[0].text}")

# macOS / Linux
curl -fsSL https://claude.ai/install.sh | sh

# npm (alternatywnie)
npm install -g @anthropic-ai/claude-code

# Weryfikacja instalacji
claude --version

# Rozpoczęcie interaktywnej sesji
claude

# Przekazanie zadania jako argument
claude "Zrefaktoruj funkcję w pliku utils.ts"

# Kontynuacja poprzedniej sesji
claude --continue

# Tryb non-interactive (pipe)
cat error.log | claude "Przeanalizuj te błędy i zaproponuj poprawki"

# Claude Code może:

# 1. Czytać i edytować pliki
claude "Dodaj walidację formularza do components/LoginForm.tsx"

# 2. Uruchamiać komendy terminalowe
claude "Zainstaluj i skonfiguruj ESLint z TypeScript"

# 3. Tworzyć nowe projekty
claude "Stwórz nowy projekt Next.js z Tailwind, Prisma i NextAuth"

# 4. Debugować problemy
claude "Dlaczego testy w jest.config.js nie działają?"

# 5. Refaktorować kod
claude "Zmień ten komponent klasowy na funkcyjny z hooks"

# 6. Generować dokumentację
claude "Dodaj JSDoc do wszystkich funkcji w src/utils/"

# Project: E-commerce Platform

## Stack
- Next.js 14 App Router
- TypeScript (strict mode)
- Prisma + PostgreSQL
- TailwindCSS
- Stripe for payments

## Conventions
- Use functional components with hooks
- Prefer server components where possible
- Keep components under 200 lines
- Write tests for all business logic

## Directory Structure
- app/ - Next.js App Router pages
- components/ - Reusable UI components
- lib/ - Utilities and helpers
- prisma/ - Database schema and migrations

## Commands
- npm run dev - Start development server
- npm run test - Run tests
- npm run db:migrate - Run database migrations

# Scenariusz: Dodawanie nowej funkcji

$ claude
╭─────────────────────────────────────────────╮
│ Claude Code v1.0.0                          │
│ Working in: /projects/my-app                │
╰─────────────────────────────────────────────╯

You: Dodaj endpoint API do obsługi płatności Stripe

Claude: Przeanalizuję obecną strukturę projektu i dodam
endpoint płatności. Wykonam następujące kroki:

1. Sprawdzę czy Stripe jest zainstalowany
2. Utworzę endpoint API w app/api/payments/route.ts
3. Dodam typy TypeScript
4. Utworzę funkcję pomocniczą do weryfikacji webhook

[Wykonuję: npm list stripe]
[Tworzę: app/api/payments/route.ts]
[Tworzę: lib/stripe.ts]
[Aktualizuję: .env.example]

Gotowe! Oto co zostało dodane:
- app/api/payments/route.ts - endpoint POST do tworzenia sesji
- lib/stripe.ts - konfiguracja klienta Stripe
- Dodano zmienne STRIPE_SECRET_KEY i STRIPE_WEBHOOK_SECRET do .env.example

Czy chcesz, żebym dodał też obsługę webhooków?

pip install anthropic-agent-sdk

from anthropic_agent import Agent, Tool, Memory

# Definiowanie narzędzi dla agenta
class FileReadTool(Tool):
    name = "read_file"
    description = "Czyta zawartość pliku"

    def run(self, path: str) -> str:
        with open(path, 'r') as f:
            return f.read()

class FileWriteTool(Tool):
    name = "write_file"
    description = "Zapisuje zawartość do pliku"

    def run(self, path: str, content: str) -> str:
        with open(path, 'w') as f:
            f.write(content)
        return f"Zapisano do {path}"

class ShellTool(Tool):
    name = "shell"
    description = "Wykonuje komendę shell"

    def run(self, command: str) -> str:
        import subprocess
        result = subprocess.run(
            command, shell=True, capture_output=True, text=True
        )
        return result.stdout + result.stderr

# Tworzenie agenta
agent = Agent(
    model="claude-sonnet-4-5-20241022",
    tools=[FileReadTool(), FileWriteTool(), ShellTool()],
    memory=Memory(max_tokens=100000),
    system_prompt="""Jesteś doświadczonym programistą Python.
    Twoim zadaniem jest pomaganie w rozwoju projektów.
    Zawsze testuj swoje zmiany przed zgłoszeniem."""
)

# Uruchomienie agenta
result = agent.run(
    "Dodaj nowy endpoint /api/users do aplikacji Flask w app.py"
)
print(result)

from anthropic_agent import Agent, PersistentMemory

# Pamięć zachowywana między sesjami
memory = PersistentMemory(
    storage_path="./agent_memory",
    max_entries=1000
)

agent = Agent(
    model="claude-sonnet-4-5-20241022",
    memory=memory,
    tools=[...],
    system_prompt="Jesteś asystentem projektu. Pamiętaj o poprzednich sesjach."
)

# Agent pamięta poprzednie interakcje
agent.run("Kontynuuj pracę nad funkcją, którą zaczęliśmy wczoraj")

# ❌ Zbyt ogólne
"Napisz kod do sortowania"

# ✅ Szczegółowe
"""Napisz funkcję TypeScript, która:
- Sortuje tablicę obiektów User po polu 'createdAt' (Date)
- Obsługuje zarówno rosnący jak i malejący porządek
- Jest wydajna dla tablic do 10000 elementów
- Ma pełne typy TypeScript
- Zawiera testy jednostkowe w Jest"""

prompt = """
# Zadanie
Przeanalizuj poniższy kod pod kątem bezpieczeństwa.

# Kod do analizy
```python
def login(username, password):
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    return db.execute(query)

3. **Dawaj przykłady (Few-shot prompting)**

```python
prompt = """
Przekształć opisy w format JSON.

Przykład 1:
Input: "Jan Kowalski, 35 lat, programista z Warszawy"
Output: {"name": "Jan Kowalski", "age": 35, "occupation": "programista", "city": "Warszawa"}

Przykład 2:
Input: "Anna Nowak, 28 lat, lekarka z Krakowa"
Output: {"name": "Anna Nowak", "age": 28, "occupation": "lekarka", "city": "Kraków"}

Teraz przekształć:
Input: "Piotr Wiśniewski, 42 lata, architekt z Gdańska"
Output:"""

prompt = """
Rozwiąż ten problem krok po kroku, wyjaśniając swoje rozumowanie.

Problem: Mamy API endpoint, który czasami zwraca błąd 500.
Logi pokazują "Connection refused" do bazy Redis.
Redis działa na tym samym serwerze.
Błąd występuje tylko w godzinach szczytu (12-14).

Przeanalizuj możliwe przyczyny i zaproponuj rozwiązania.
Pokaż swoje rozumowanie przed każdą konkluzją.
"""

system_prompt = """Jesteś Staff Engineer w firmie FAANG z 15-letnim
doświadczeniem. Specjalizujesz się w:
- Systemach rozproszonych
- High-performance computing
- Mentoringu juniorów

Twój styl komunikacji:
- Konkretny i rzeczowy
- Używasz analogii do wyjaśniania złożonych konceptów
- Zawsze wspominasz o trade-offs
- Dajesz praktyczne przykłady z produkcji"""

prompt = """
<context>
Pracujesz nad aplikacją e-commerce w Next.js.
Stack: Next.js 14, Prisma, PostgreSQL, Stripe.
</context>

<current_code>
// components/Cart.tsx
export function Cart({ items }) {
  return (
    <div>
      {items.map(item => <CartItem key={item.id} {...item} />)}
    </div>
  )
}
</current_code>

<task>
Dodaj funkcjonalność:
1. Obliczanie łącznej sumy
2. Przycisk "Przejdź do płatności"
3. Obsługa pustego koszyka
</task>

<constraints>
- Użyj TypeScript z pełnymi typami
- Komponent ma być server component gdzie możliwe
- Styling w Tailwind CSS
</constraints>
"""

# Pierwszy prompt
response1 = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    messages=[
        {"role": "user", "content": "Napisz funkcję do walidacji emaila"}
    ]
)

# Iteracja z feedbackiem
response2 = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    messages=[
        {"role": "user", "content": "Napisz funkcję do walidacji emaila"},
        {"role": "assistant", "content": response1.content[0].text},
        {"role": "user", "content": """Świetnie! Teraz:
        1. Dodaj obsługę subdomen
        2. Zwaliduj też długość local-part (max 64 znaki)
        3. Dodaj testy dla edge cases"""}
    ]
)

// app/api/chat/route.ts
import Anthropic from '@anthropic-ai/sdk'
import { NextResponse } from 'next/server'

const anthropic = new Anthropic()

export async function POST(request: Request) {
  const { messages, systemPrompt } = await request.json()

  try {
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-4-5-20241022',
      max_tokens: 4096,
      system: systemPrompt || 'Jesteś pomocnym asystentem.',
      messages: messages.map((m: any) => ({
        role: m.role,
        content: m.content
      }))
    })

    return NextResponse.json({
      message: response.content[0].text,
      usage: response.usage
    })
  } catch (error) {
    console.error('Claude API error:', error)
    return NextResponse.json(
      { error: 'Błąd komunikacji z AI' },
      { status: 500 }
    )
  }
}

// components/ChatInterface.tsx
'use client'

import { useState } from 'react'

interface Message {
  role: 'user' | 'assistant'
  content: string
}

export function ChatInterface() {
  const [messages, setMessages] = useState<Message[]>([])
  const [input, setInput] = useState('')
  const [isLoading, setIsLoading] = useState(false)

  const sendMessage = async () => {
    if (!input.trim()) return

    const userMessage: Message = { role: 'user', content: input }
    setMessages(prev => [...prev, userMessage])
    setInput('')
    setIsLoading(true)

    try {
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          messages: [...messages, userMessage]
        })
      })

      const data = await response.json()

      setMessages(prev => [
        ...prev,
        { role: 'assistant', content: data.message }
      ])
    } catch (error) {
      console.error('Error:', error)
    } finally {
      setIsLoading(false)
    }
  }

  return (
    <div className="flex flex-col h-screen max-w-2xl mx-auto">
      <div className="flex-1 overflow-y-auto p-4 space-y-4">
        {messages.map((message, index) => (
          <div
            key={index}
            className={`p-4 rounded-lg ${
              message.role === 'user'
                ? 'bg-blue-100 ml-8'
                : 'bg-gray-100 mr-8'
            }`}
          >
            {message.content}
          </div>
        ))}
        {isLoading && (
          <div className="bg-gray-100 p-4 rounded-lg mr-8 animate-pulse">
            Myślę...
          </div>
        )}
      </div>

      <div className="p-4 border-t">
        <div className="flex gap-2">
          <input
            type="text"
            value={input}
            onChange={(e) => setInput(e.target.value)}
            onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
            placeholder="Napisz wiadomość..."
            className="flex-1 p-2 border rounded-lg"
            disabled={isLoading}
          />
          <button
            onClick={sendMessage}
            disabled={isLoading}
            className="px-4 py-2 bg-blue-500 text-white rounded-lg
                     hover:bg-blue-600 disabled:opacity-50"
          >
            Wyślij
          </button>
        </div>
      </div>
    </div>
  )
}

// app/api/chat/stream/route.ts
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

export async function POST(request: Request) {
  const { messages } = await request.json()

  const stream = await anthropic.messages.stream({
    model: 'claude-sonnet-4-5-20241022',
    max_tokens: 4096,
    messages
  })

  const encoder = new TextEncoder()

  const readable = new ReadableStream({
    async start(controller) {
      for await (const event of stream) {
        if (event.type === 'content_block_delta' &&
            event.delta.type === 'text_delta') {
          controller.enqueue(
            encoder.encode(`data: ${JSON.stringify({ text: event.delta.text })}\n\n`)
          )
        }
      }
      controller.enqueue(encoder.encode('data: [DONE]\n\n'))
      controller.close()
    }
  })

  return new Response(readable, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive'
    }
  })
}

from anthropic import Anthropic
import chromadb
from sentence_transformers import SentenceTransformer

# Inicjalizacja
client = Anthropic()
chroma = chromadb.Client()
collection = chroma.create_collection("docs")
embedder = SentenceTransformer('all-MiniLM-L6-v2')

def add_documents(documents: list[str]):
    """Dodaj dokumenty do bazy wektorowej"""
    embeddings = embedder.encode(documents).tolist()
    collection.add(
        embeddings=embeddings,
        documents=documents,
        ids=[f"doc_{i}" for i in range(len(documents))]
    )

def query_with_rag(question: str) -> str:
    """Odpowiedz na pytanie z wykorzystaniem RAG"""
    # 1. Znajdź relevantne dokumenty
    query_embedding = embedder.encode([question]).tolist()
    results = collection.query(
        query_embeddings=query_embedding,
        n_results=3
    )

    context = "\n\n".join(results['documents'][0])

    # 2. Wygeneruj odpowiedź z kontekstem
    message = client.messages.create(
        model="claude-sonnet-4-5-20241022",
        max_tokens=2048,
        system="""Odpowiadaj na pytania na podstawie dostarczonego kontekstu.
        Jeśli kontekst nie zawiera odpowiedzi, powiedz o tym wprost.""",
        messages=[
            {
                "role": "user",
                "content": f"""Kontekst:
{context}

Pytanie: {question}

Odpowiedź:"""
            }
        ]
    )

    return message.content[0].text

# Użycie
add_documents([
    "Next.js 14 wprowadza App Router z Server Components...",
    "Prisma to nowoczesny ORM dla TypeScript i Node.js...",
    "TailwindCSS pozwala na utility-first styling..."
])

answer = query_with_rag("Jak działa App Router w Next.js?")
print(answer)

import anthropic
from anthropic import APIError, RateLimitError, APIConnectionError

client = anthropic.Anthropic()

def safe_call(messages: list, retries: int = 3):
    for attempt in range(retries):
        try:
            response = client.messages.create(
                model="claude-sonnet-4-5-20241022",
                max_tokens=1024,
                messages=messages
            )
            return response
        except RateLimitError:
            if attempt < retries - 1:
                import time
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            raise
        except APIConnectionError as e:
            print(f"Connection error: {e}")
            raise
        except APIError as e:
            print(f"API error: {e}")
            raise

# 1. Nigdy nie umieszczaj API key w kodzie
import os
api_key = os.environ.get("ANTHROPIC_API_KEY")

# 2. Waliduj input użytkownika
def sanitize_input(user_input: str) -> str:
    # Ogranicz długość
    if len(user_input) > 10000:
        raise ValueError("Input too long")

    # Usuń potencjalnie niebezpieczne treści
    # (prompt injection prevention)
    return user_input.strip()

# 3. Ogranicz output
message = client.messages.create(
    model="claude-sonnet-4-5-20241022",
    max_tokens=1000,  # Zawsze ustawiaj limit
    messages=[...]
)

# 4. Monitoruj usage
print(f"Tokens used: {message.usage.input_tokens + message.usage.output_tokens}")

# 5. Implementuj rate limiting w swojej aplikacji
from functools import lru_cache
import time

last_call_time = {}

def rate_limited_call(user_id: str, messages: list):
    now = time.time()
    if user_id in last_call_time:
        elapsed = now - last_call_time[user_id]
        if elapsed < 1:  # 1 request per second per user
            time.sleep(1 - elapsed)

    last_call_time[user_id] = time.time()
    return client.messages.create(...)