Agent AI Claude to zaawansowany asystent, który może wykonywać złożone zadania autonomicznie. W tym artykule dowiesz się, jak zbudować prostego agenta AI korzystając z możliwości Claude Code - od podstawowej konfiguracji po implementację konkretnych funkcjonalności. Przedstawię praktyczne przykłady kodu, najlepsze praktyki oraz tipsy, które pozwolą Ci stworzyć działającego agenta w kilka godzin.
Czym jest agent AI i dlaczego Claude Code
Agent AI to program komputerowy zdolny do autonomicznego wykonywania zadań, podejmowania decyzji i interakcji z otoczeniem. W przeciwieństwie do tradycyjnych chatbotów, agenty AI mogą:
- Analizować kontekst i planować działania
- Wykonywać sekwencje zadań bez ciągłej supervizji
- Integrować się z zewnętrznymi systemami i API
- Uczić się z doświadczeń i adaptować zachowanie
Claude Code od Anthropic wyróżnia się na tle konkurencji kilkoma kluczowymi zaletami:
- Bezpieczeństwo: Wbudowane mechanizmy Constitutional AI redukują ryzyko niepożądanych zachowań
- Długi kontekst: Do 200,000 tokenów pozwala na przetwarzanie obszernych dokumentów
- Jakość kodu: Generuje czytelny, dobrze udokumentowany kod w różnych językach
- Łatwość integracji: Prosty REST API z obszerną dokumentacją
Według raportu McKinsey z 2023 roku, organizacje wykorzystujące agenty AI odnotowują średnio 15-25% wzrost produktywności w procesach automatyzacji.
Przygotowanie środowiska pracy
Wymagania systemowe
Do budowy agenta AI z Claude potrzebujesz:
- Python 3.8+ (zalecana wersja 3.10)
- Git do zarządzania kodem
- IDE: VS Code, PyCharm lub podobne
- Klucz API: Konto w Anthropic Console
- System operacyjny: Windows 10+, macOS 10.15+, lub Linux
Instalacja niezbędnych bibliotek
Utwórz nowy projekt i zainstaluj wymagane pakiety:
bashpip install anthropic python-dotenv requests beautifulsoup4 schedule
Konfiguracja klucza API
- Zarejestruj się na console.anthropic.com
- Wygeneruj klucz API w sekcji "API Keys"
- Utwórz plik
.envw katalogu projektu:
ANTHROPIC_API_KEY=your_api_key_here
Ważne: Nigdy nie commituj pliku .env do repozytorium. Dodaj go do .gitignore.
Struktura projektu
Zorganizuj kod w przejrzystą strukturę:
ai_agent/
├── main.py
├── agent/
│ ├── __init__.py
│ ├── core.py
│ └── tools.py
├── config/
│ └── settings.py
└── .env
Podstawowa architektura agenta
Claude agent składa się z kilku kluczowych komponentów:
1. Główny kontroler (Agent Core)
To serce agenta odpowiedzialne za:
- Komunikację z Claude API
- Zarządzanie kontekstem rozmowy
- Koordynację działań między narzędziami
pythonimport anthropic import os from dotenv import load_dotenv load_dotenv() class ClaudeAgent: def __init__(self): self.client = anthropic.Anthropic( api_key=os.getenv('ANTHROPIC_API_KEY') ) self.conversation_history = [] def send_message(self, message, max_tokens=1000): response = self.client.messages.create( model="claude-3-sonnet-20240229", max_tokens=max_tokens, messages=[{"role": "user", "content": message}] ) return response.content[0].text
2. System narzędzi (Tools)
Agent potrzebuje sposobu interakcji ze światem zewnętrznym:
pythonclass AgentTools: @staticmethod def web_search(query): # Implementacja wyszukiwania import requests # Przykład z wykorzystaniem DuckDuckGo API url = f"https://api.duckduckgo.com/?q={query}&format=json" response = requests.get(url) return response.json() @staticmethod def save_file(content, filename): with open(filename, 'w', encoding='utf-8') as f: f.write(content) return f"Zapisano plik: {filename}"
3. Manager kontekstu
Utrzymuje ciągłość rozmowy i pamięć agenta:
pythonclass ContextManager: def __init__(self, max_history=10): self.max_history = max_history self.memory = [] def add_interaction(self, user_input, agent_response): self.memory.append({ 'timestamp': datetime.now(), 'user': user_input, 'agent': agent_response }) if len(self.memory) > self.max_history: self.memory.pop(0)
Implementacja podstawowych funkcji
Funkcja przetwarzania zapytań
Stwórz główną logikę przetwarzania requestów:
pythonclass SmartAgent(ClaudeAgent): def __init__(self): super().__init__() self.tools = AgentTools() self.context = ContextManager() def process_request(self, user_input): # Analiza intencji użytkownika intent_prompt = f""" Przeanalizuj następujące zapytanie użytkownika i określ, czy wymaga ono użycia narzędzi zewnętrznych: Zapytanie: {user_input} Odpowiedz w formacie JSON: {{ "needs_tools": true/false, "tool_type": "search/file/calculation/none", "reasoning": "uzasadnienie" }} """ intent_analysis = self.send_message(intent_prompt) # Parsowanie odpowiedzi i wykonanie akcji return self._execute_action(user_input, intent_analysis)
System podejmowania decyzji
Agent musi umieć wybierać odpowiednie narzędzia:
pythondef _execute_action(self, user_input, intent_analysis): try: import json intent_data = json.loads(intent_analysis) if intent_data.get('needs_tools'): tool_type = intent_data.get('tool_type') if tool_type == 'search': search_results = self.tools.web_search(user_input) return self._generate_response_with_data(user_input, search_results) elif tool_type == 'file': return self._handle_file_operation(user_input) # Standardowa odpowiedź bez narzędzi return self.send_message(user_input) except json.JSONDecodeError: # Fallback dla błędów parsowania return self.send_message(user_input)
Dodawanie zaawansowanych funkcjonalności
Integracja z API zewnętrznymi
Tutorial AI agent nie byłby kompletny bez pokazania integracji z prawdziwymi serwisami:
pythonclass AdvancedTools(AgentTools): def __init__(self): self.weather_api_key = os.getenv('WEATHER_API_KEY') def get_weather(self, city): url = f"http://api.openweathermap.org/data/2.5/weather" params = { 'q': city, 'appid': self.weather_api_key, 'units': 'metric', 'lang': 'pl' } response = requests.get(url, params=params) if response.status_code == 200: data = response.json() return { 'temperature': data['main']['temp'], 'description': data['weather'][0]['description'], 'humidity': data['main']['humidity'] } return None def send_email_notification(self, recipient, subject, body): # Implementacja wysyłania emaili import smtplib from email.mime.text import MIMEText # Konfiguracja SMTP server = smtplib.SMTP('smtp.gmail.com', 587) server.starttls() # Implementacja wysyłania
System harmonogramowania zadań
Agent może wykonywać zadania w określonych intervalach:
pythonimport schedule import threading import time class ScheduledAgent(SmartAgent): def __init__(self): super().__init__() self.scheduler_running = False def schedule_task(self, task_description, interval_minutes): def job(): prompt = f"Wykonaj następujące zadanie: {task_description}" result = self.process_request(prompt) print(f"Zadanie wykonane: {result}") schedule.every(interval_minutes).minutes.do(job) if not self.scheduler_running: self._start_scheduler() def _start_scheduler(self): def run_scheduler(): self.scheduler_running = True while self.scheduler_running: schedule.run_pending() time.sleep(60) thread = threading.Thread(target=run_scheduler) thread.daemon = True thread.start()
Persystencja danych
Agent powinien pamiętać informacje między sesjami:
pythonimport json import sqlite3 from datetime import datetime class PersistentAgent(ScheduledAgent): def __init__(self, db_path='agent_memory.db'): super().__init__() self.db_path = db_path self._init_database() def _init_database(self): conn = sqlite3.connect(self.db_path) cursor = conn.cursor() cursor.execute(''' CREATE TABLE IF NOT EXISTS conversations ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME, user_input TEXT, agent_response TEXT ) ''') conn.commit() conn.close() def save_interaction(self, user_input, agent_response): conn = sqlite3.connect(self.db_path) cursor = conn.cursor() cursor.execute(''' INSERT INTO conversations (timestamp, user_input, agent_response) VALUES (?, ?, ?) ''', (datetime.now(), user_input, agent_response)) conn.commit() conn.close()
Testowanie i debugowanie agenta
Unit testy
Utwórz testy sprawdzające poszczególne komponenty:
pythonimport unittest from unittest.mock import patch, MagicMock class TestClaudeAgent(unittest.TestCase): def setUp(self): self.agent = SmartAgent() @patch('anthropic.Anthropic') def test_send_message(self, mock_anthropic): # Mock odpowiedzi API mock_response = MagicMock() mock_response.content = [MagicMock(text="Test response")] mock_client = MagicMock() mock_client.messages.create.return_value = mock_response mock_anthropic.return_value = mock_client result = self.agent.send_message("Test message") self.assertEqual(result, "Test response") def test_context_manager(self): context = ContextManager(max_history=2) context.add_interaction("Pytanie 1", "Odpowiedź 1") context.add_interaction("Pytanie 2", "Odpowiedź 2") context.add_interaction("Pytanie 3", "Odpowiedź 3") self.assertEqual(len(context.memory), 2) self.assertEqual(context.memory[0]['user'], "Pytanie 2") if __name__ == '__main__': unittest.main()
Monitoring i logi
Dodaj system logowania do śledzenia działania agenta:
pythonimport logging from datetime import datetime class MonitoredAgent(PersistentAgent): def __init__(self, db_path='agent_memory.db'): super().__init__(db_path) self._setup_logging() def _setup_logging(self): logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('agent.log'), logging.StreamHandler() ] ) self.logger = logging.getLogger(__name__) def process_request(self, user_input): self.logger.info(f"Processing request: {user_input[:100]}...") try: response = super().process_request(user_input) self.logger.info(f"Response generated successfully") return response except Exception as e: self.logger.error(f"Error processing request: {str(e)}") return "Przepraszam, wystąpił błąd podczas przetwarzania Twojego zapytania."
Metryki wydajności
Śledź kluczowe wskaźniki działania agenta:
pythonimport time from collections import defaultdict class MetricsAgent(MonitoredAgent): def __init__(self, db_path='agent_memory.db'): super().__init__(db_path) self.metrics = defaultdict(list) def process_request_with_metrics(self, user_input): start_time = time.time() response = self.process_request(user_input) end_time = time.time() processing_time = end_time - start_time self.metrics['response_times'].append(processing_time) self.metrics['request_count'].append(1) self.logger.info(f"Request processed in {processing_time:.2f} seconds") return response def get_performance_stats(self): if not self.metrics['response_times']: return "Brak danych o wydajności" avg_time = sum(self.metrics['response_times']) / len(self.metrics['response_times']) total_requests = sum(self.metrics['request_count']) return f""" Statystyki wydajności: - Średni czas odpowiedzi: {avg_time:.2f}s - Łączna liczba zapytań: {total_requests} - Najdłuższy czas odpowiedzi: {max(self.metrics['response_times']):.2f}s """
Optymalizacja i najlepsze praktyki
Zarządzanie tokenami
Claude ma limity tokenów, więc optymalizuj zapytania:
pythonclass OptimizedAgent(MetricsAgent): def __init__(self, db_path='agent_memory.db'): super().__init__(db_path) self.max_context_tokens = 4000 def _truncate_context(self, text, max_tokens): # Proste przybliżenie: 1 token ≈ 4 znaki max_chars = max_tokens * 4 if len(text) > max_chars: return text[-max_chars:] return text def send_message_optimized(self, message): # Ogranicz kontekst do najważniejszych informacji truncated_message = self._truncate_context(message, self.max_context_tokens) return super().send_message(truncated_message, max_tokens=1000)
Cache'owanie odpowiedzi
Uniknij powtarzania kosztownych zapytań:
pythonimport hashlib from functools import lru_cache class CachedAgent(OptimizedAgent): def __init__(self, db_path='agent_memory.db'): super().__init__(db_path) self.response_cache = {} def _get_cache_key(self, message): return hashlib.md5(message.encode()).hexdigest() def send_message_cached(self, message, use_cache=True): if not use_cache: return self.send_message_optimized(message) cache_key = self._get_cache_key(message) if cache_key in self.response_cache: self.logger.info("Using cached response") return self.response_cache[cache_key] response = self.send_message_optimized(message) self.response_cache[cache_key] = response return response
Jeśli chcesz pogłębić swoją wiedzę o budowie agentów AI i nauczyć się zaawansowanych technik automatyzacji, polecam kurs AI Agents: Budowanie Autonomicznych Asystentów. Program obejmuje praktyczne projekty, integracje z popularnymi API oraz strategie wdrażania agentów w biznesie. Z kodem BLOG15 otrzymasz 15% zniżki na całość kursu.
FAQ - Najczęściej zadawane pytania
Ile kosztuje korzystanie z Claude API?
Ceny Claude API zależą od modelu i liczby tokenów. Claude-3 Sonnet kosztuje około $3 za milion tokenów wejściowych i $15 za milion tokenów wyjściowych. Dla prostego agenta obsługującego 100-200 zapytań dziennie, miesięczny koszt to około $10-30.
Czy mogę uruchomić agenta na własnym serwerze?
Tak, możesz wdrożyć agenta na dowolnym serwerze z Pythonem 3.8+. Popularne opcje to DigitalOcean, AWS EC2, czy Google Cloud. Pamiętaj o zabezpieczeniu klucza API i regularnych backup'ach bazy danych.
Jakie są ograniczenia Claude w porównaniu do GPT-4?
Claude charakteryzuje się większym kontekstem (200k vs 32k tokenów), lepszym bezpieczeństwem i odmową szkodliwych zapytań. GPT-4 ma szerszą bazę wtyczek i integracji. Wybór zależy od konkretnego przypadku użycia.
Jak dodać obsługę języka polskiego?
Claude natywnie obsługuje język polski. W promptach używaj polskich instrukcji, a model automatycznie dostosuje odpowiedzi. Dla lepszych rezultatów, dodaj na początku rozmowy: "Odpowiadaj zawsze w języku polskim, używając naturalnych zwrotów."
Czy agent może integrować się z bazami danych?
Tak, agent może łączyć się z dowolnymi bazami danych przez odpowiednie sterowniki Python (psycopg2 dla PostgreSQL, pymongo dla MongoDB, etc.). Pamiętaj o implementacji proper validation i sanitization zapytań SQL aby uniknąć injection attacks.
