Jak zintegrować AI z narzędziami zewnętrznymi za pomocą API i webhooków

Wprowadzenie

Konwergencja sztucznej inteligencji i aplikacji zewnętrznych fundamentalnie zmieniła sposób funkcjonowania biznesu. Współczesne przedsiębiorstwa nie korzystają już z odizolowanych systemów AI – zamiast tego wdrażają zaawansowane integracje, łącząc modele AI z platformami CRM, bramkami płatności, narzędziami komunikacyjnymi i wieloma innymi usługami. Ten kompleksowy przewodnik omawia techniczne i strategiczne podejścia do integracji AI z narzędziami zewnętrznymi przy pomocy API i webhooków, dostarczając wiedzy niezbędnej do budowy solidnych, skalowalnych i bezpiecznych przepływów pracy opartych na AI.

Niezależnie od tego, czy jesteś deweloperem tworzącym swoją pierwszą integrację AI, czy architektem korporacyjnym projektującym złożone systemy automatyzacji, zrozumienie niuansów integracji AI opartej na API i webhookach jest kluczowe. Ten artykuł przeprowadzi Cię przez cały proces – od podstawowych pojęć po zaawansowane wzorce wdrożeniowe – byś mógł z pewnością połączyć możliwości AI z istniejącym stosem technologicznym.

Czym są API i webhooki?

Zanim zagłębimy się w strategie integracji, warto poznać zasadniczą różnicę między tymi dwoma paradygmatami komunikacji. API (Application Programming Interface) to zestaw protokołów i narzędzi umożliwiających komunikację różnych aplikacji programistycznych. API opierają się na modelu typu pull, co oznacza, że Twoja aplikacja aktywnie żąda danych lub usług z systemu zewnętrznego. Gdy potrzebujesz informacji, inicjujesz żądanie, czekasz na odpowiedź i przetwarzasz zwrócone dane.

Webhook natomiast działa w modelu typu push. Zamiast nieustannie pytać o nowe dane, webhooki pozwalają systemom zewnętrznym samodzielnie przesyłać dane do Twojej aplikacji w momencie wystąpienia określonych zdarzeń. To jak różnica między ciągłym sprawdzaniem skrzynki pocztowej a dostawą listu bezpośrednio pod drzwi, gdy tylko nadejdzie.

API zazwyczaj wykorzystuje się do operacji na żądanie – pobierania informacji o użytkowniku, przetwarzania płatności, generowania predykcji AI czy pobierania danych w czasie rzeczywistym. Webhooki zaś sprawdzają się w scenariuszach zdarzeniowych, gdzie trzeba natychmiast powiadomić o czymś, co się wydarzyło: przetworzeniu płatności, przesłaniu formularza, dodaniu pliku czy wykonaniu konkretnej akcji przez użytkownika.

Wybór pomiędzy API a webhookami zależy często od Twojego przypadku użycia. Wiele zaawansowanych integracji wykorzystuje oba podejścia równolegle – API do pobierania danych, webhooki do odbierania powiadomień w czasie rzeczywistym. Takie hybrydowe rozwiązanie daje elastyczność i responsywność, jakich wymagają nowoczesne aplikacje.

Dlaczego integracja AI z narzędziami zewnętrznymi jest ważna dla biznesu

Biznesowe uzasadnienie dla integracji AI z narzędziami zewnętrznymi jest przekonujące i wielowymiarowe. Organizacje, które skutecznie wdrażają takie integracje, zyskują przewagę konkurencyjną w wielu obszarach.

Efektywność operacyjna i redukcja kosztów: Gdy systemy AI są odizolowane od narzędzi biznesowych, powstają silosy danych i manualne punkty przekazywania zadań. Bezpośrednia integracja AI z CRM, platformą e-mail, narzędziami do zarządzania projektami i innymi aplikacjami eliminuje te wąskie gardła. Zamiast ręcznie kopiować dane między systemami, AI może automatycznie przetwarzać informacje, generować wnioski i wywoływać akcje w całym środowisku technologicznym. Taka automatyzacja obniża koszty operacyjne, minimalizuje błędy ludzkie i pozwala zespołowi skupić się na zadaniach strategicznych.

Podejmowanie decyzji w czasie rzeczywistym: Webhooki umożliwiają AI natychmiastową reakcję na zdarzenia biznesowe. Gdy klient zgłasza zgłoszenie do supportu, AI może natychmiast przeanalizować jego sentyment i przekierować sprawę do odpowiedniego zespołu. Gdy pojawią się nowe dane sprzedażowe, AI natychmiast aktualizuje prognozy. Gdy zapasy spadną poniżej progu, AI automatycznie generuje zamówienie. Taka responsywność zmienia sposób, w jaki organizacje reagują na zmiany rynkowe i potrzeby klientów.

Lepsze doświadczenie klienta: Zintegrowane systemy AI zapewniają płynne, spersonalizowane doświadczenia. Chatbot AI zintegrowany z CRM może korzystać z historii klienta, by udzielać kontekstowych odpowiedzi. Silnik rekomendacji AI podłączony do platformy e-commerce może podsuwać produkty dopasowane do preferencji. Asystent AI zintegrowany z kalendarzem sam znajdzie wolny termin spotkania. Takie integracje tworzą bezproblemowe doświadczenia, które klienci doceniają i które budują lojalność.

Wgląd w dane na dużą skalę: Łącząc AI z wieloma źródłami danych poprzez API, firmy mogą budować złożone systemy analityczne obejmujące całą organizację. Taki scentralizowany widok pozwala na precyzyjniejsze prognozy, lepsze rozpoznawanie wzorców i wnioski, które byłyby niemożliwe do uzyskania przy rozproszonych danych.

Zwróć uwagę na te kluczowe korzyści:

• Automatyzacja powtarzalnych zadań na wielu platformach bez ręcznej ingerencji
• Scentralizowane przetwarzanie danych łączące informacje z różnych źródeł dla bogatszej analizy AI
• Skalowalność, która pozwala AI obsłużyć rosnące wolumeny danych i żądań
• Elastyczność w dostosowywaniu przepływów AI do zmieniających się potrzeb biznesowych
• Zgodność i ścieżki audytu poprzez scentralizowane logowanie i monitoring wszystkich integracji

Podstawy API w integracji AI

API stanowią fundament większości integracji AI. Aby skutecznie łączyć AI z narzędziami zewnętrznymi, musisz zrozumieć, jak działają API i jak się z nimi komunikować programistycznie.

Typy i architektury API

Współczesne API występują w kilku odmianach o różnych właściwościach. REST (Representational State Transfer) API to najpopularniejszy typ. Wykorzystują standardowe metody HTTP (GET, POST, PUT, DELETE) do operacji na zasobach identyfikowanych przez URL. REST API są bezstanowe, czyli każde żądanie zawiera wszystkie niezbędne informacje, co upraszcza implementację.

GraphQL API to bardziej elastyczna alternatywa – klient może pobrać dokładnie te dane, których potrzebuje, zamiast dostawać predefiniowaną strukturę odpowiedzi. Jest to efektywne przy złożonych zapytaniach, ale wymaga bardziej zaawansowanego klienta.

SOAP (Simple Object Access Protocol) API to starszy, oparty na XML protokół, nadal używany w środowiskach korporacyjnych. Jest bardziej złożony od REST, ale oferuje rozbudowane możliwości integracji.

RPC (Remote Procedure Call) API pozwala wywoływać funkcje na zdalnych serwerach jakby były lokalne. Niektóre API blockchaina i kryptowalut korzystają z tego wzorca.

W większości integracji AI spotkasz się z REST API, które oferują najlepszy kompromis między prostotą a funkcjonalnością.

Uwierzytelnianie i bezpieczeństwo

Każda interakcja z API wymaga uwierzytelnienia, by potwierdzić, że Twoja aplikacja ma prawo dostępu do usługi. Zrozumienie mechanizmów uwierzytelniania jest kluczowe dla bezpieczeństwa integracji AI.

Klucze API to najprostsza metoda. Otrzymujesz unikalny klucz podczas rejestracji usługi API i dołączasz go do żądań. Choć łatwe w implementacji, mają ograniczenia – nie wygasają automatycznie i dają pełny dostęp. Nadają się do środowisk deweloperskich i mniej wrażliwych operacji, ale nie powinny być jedyną warstwą bezpieczeństwa w produkcji.

OAuth 2.0 to branżowy standard autoryzacji delegowanej. Zamiast udostępniać swoje dane logowania, OAuth pozwala użytkownikom upoważnić Twoją aplikację do dostępu do ich danych w ich imieniu. To znane z uprawnień typu “uzyskaj dostęp do konta Google” czy “połącz ze Slackiem”. OAuth jest bardziej złożony, ale zapewnia wyższy poziom bezpieczeństwa i kontroli.

Bearer tokeny i JWT (JSON Web Tokens) łączą prostotę kluczy API z dodatkowymi zabezpieczeniami. JWT to kryptograficznie podpisane tokeny zawierające informacje o użytkowniku lub aplikacji, m.in. czas wygaśnięcia, uprawnienia i inne metadane. Idealne do mikroserwisów i systemów rozproszonych.

Mutual TLS (mTLS) wykorzystuje certyfikaty zarówno po stronie klienta, jak i serwera, oferując najwyższy poziom bezpieczeństwa. To rozwiązanie popularne w korporacjach i do operacji wrażliwych.

Wywołania API

Interakcja z API polega na budowaniu żądań HTTP z odpowiednimi nagłówkami, parametrami i treścią. Oto praktyczny przykład wywołania AI API:

import requests
import json

# Konfiguracja uwierzytelniania
headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
}

# Przygotowanie danych do żądania
data = {
    'model': 'gpt-4',
    'messages': [
        {
            'role': 'user',
            'content': 'Przeanalizuj tę opinię klienta pod kątem sentymentu'
        }
    ],
    'temperature': 0.7,
    'max_tokens': 500,
}

# Wywołanie API
response = requests.post(
    'https://api.openai.com/v1/chat/completions',
    headers=headers,
    json=data
)

# Obsługa odpowiedzi
if response.status_code == 200:
    result = response.json()
    ai_response = result['choices'][0]['message']['content']
    print(f"Analiza AI: {ai_response}")
else:
    print(f"Błąd: {response.status_code} - {response.text}")

Ten przykład pokazuje podstawowy schemat: uwierzytelnienie, budowa żądania, wysłanie go do API, przetworzenie odpowiedzi. Większość integracji AI z API działa według tego wzorca, choć parametry i formaty odpowiedzi zależą od konkretnej usługi.

Architektura webhooków i integracja w czasie rzeczywistym

Podczas gdy API pobierają dane na żądanie, webhooki umożliwiają komunikację push w czasie rzeczywistym. Zrozumienie architektury webhooków jest kluczowe dla budowy responsywnych systemów AI.

Jak działają webhooki

Webhook to mechanizm callbacku. Rejestrujesz URL w usłudze zewnętrznej, a gdy wystąpi określone zdarzenie, usługa ta wysyła żądanie HTTP POST na Twój URL z danymi zdarzenia. Twoja aplikacja odbiera te dane, przetwarza je i podejmuje odpowiednie działania.

Schemat działania wygląda następująco:

1. Rejestrujesz URL webhooka w usłudze zewnętrznej (np. Stripe, GitHub, Slack)
2. W usłudze występuje zdarzenie (płatność, push do repozytorium, wysłana wiadomość)
3. Usługa wysyła żądanie HTTP POST na Twój URL webhooka z danymi zdarzenia
4. Twoja aplikacja odbiera i przetwarza payload webhooka
5. Twoja aplikacja zwraca odpowiedź sukcesu (zwykle HTTP 200)
6. Twoja aplikacja podejmuje działania na podstawie zdarzenia (wyzwala analizę AI, aktualizuje bazę, wysyła powiadomienie)

Tworzenie odbiornika webhooków

Stworzenie odbiornika webhooków wymaga utworzenia endpointu HTTP akceptującego żądania POST. Przykład w Flask:

from flask import Flask, request, jsonify
import hmac
import hashlib
import json

app = Flask(__name__)
WEBHOOK_SECRET = 'your_webhook_secret_key'

def verify_webhook_signature(payload, signature):
    """Weryfikacja, czy webhook pochodzi z oczekiwanego źródła"""
    expected_signature = hmac.new(
        WEBHOOK_SECRET.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected_signature)

@app.route('/webhook/payment', methods=['POST'])
def handle_payment_webhook():
    # Pobierz surowy payload do weryfikacji podpisu
    payload = request.get_data()
    signature = request.headers.get('X-Signature')
    
    # Zweryfikuj autentyczność webhooka
    if not verify_webhook_signature(payload, signature):
        return jsonify({'error': 'Nieprawidłowy podpis'}), 401
    
    # Przetwórz dane JSON
    data = request.json
    
    # Obsłuż zdarzenie webhooka
    try:
        if data['event_type'] == 'payment.completed':
            # Wywołaj analizę AI transakcji
            analyze_transaction(data['transaction_id'], data['amount'])
            
            # Zaktualizuj bazę danych
            update_payment_status(data['transaction_id'], 'completed')
            
            # Wyślij potwierdzenie
            send_confirmation_email(data['customer_email'])
        
        # Zawsze zwróć 200 jako potwierdzenie odbioru
        return jsonify({'status': 'received'}), 200
    
    except Exception as e:
        # Zaloguj błąd, ale nadal zwróć 200, by uniknąć ponownych prób
        log_error(f"Błąd przetwarzania webhooka: {str(e)}")
        return jsonify({'status': 'received'}), 200

if __name__ == '__main__':
    app.run(port=5000)

Ten przykład pokazuje kluczowe dobre praktyki: weryfikację podpisu, poprawną obsługę błędów i zawsze zwracanie odpowiedzi sukcesu, by zapobiec ponownym próbom wysyłki.

Bezpieczeństwo webhooków

Webhooki generują unikalne wyzwania bezpieczeństwa, bo usługi zewnętrzne wysyłają dane bezpośrednio do Twojej aplikacji. Kilka kluczowych środków ostrożności:

Weryfikacja podpisu: Większość dostawców webhooków dodaje podpis do nagłówków żądania, wyliczony na podstawie wspólnego sekretu. Zawsze weryfikuj ten podpis, by mieć pewność, że webhook pochodzi z właściwego źródła i nie został zmodyfikowany.

Tylko HTTPS: Zawsze korzystaj z HTTPS dla endpointów webhooków. Zapewnia to szyfrowanie w transmisji i ochronę przed atakami typu man-in-the-middle.

Whitelistowanie IP: Jeśli to możliwe, ogranicz dostęp do endpointu webhooka tylko do określonych adresów IP usług zewnętrznych.

Limitowanie żądań: Wdroż limity żądań dla endpointów webhooków, by zapobiec nadużyciom lub przypadkowemu zalaniu żądaniami.

Idempotencja: Projektuj obsługę webhooków tak, aby przetwarzanie tego samego webhooka wielokrotnie dawało ten sam efekt – dostawcy mogą ponawiać wysyłkę w przypadku problemów.

Integracja modeli AI z zewnętrznymi API

Gdy znamy już podstawy, zobaczmy, jak zintegrować modele AI z usługami zewnętrznymi. Tutaj kryje się prawdziwa moc integracji AI.

Wybór usługi AI

Rynek AI oferuje wiele opcji, różniących się możliwościami, modelem cenowym i sposobem integracji. API OpenAI daje dostęp do GPT-4, GPT-3.5 i innych modeli do przetwarzania języka naturalnego, generowania kodu czy zadań logicznych. Google Cloud AI oferuje Vertex AI, Document AI i Vision AI. AWS zapewnia SageMaker do modeli własnych i gotowe usługi AI. Claude API od Anthropic specjalizuje się w AI bezpiecznym i interpretowalnym. Hugging Face proponuje otwarte modele i hub modelowy.

Wybór zależy od: konkretnych potrzeb, budżetu, wymagań dot. opóźnień, prywatności danych i preferencji co do usług zarządzanych lub własnych rozwiązań.

Budowa pipeline’u integracji AI

Typowy pipeline integracji AI obejmuje: pobieranie danych z zewnętrznych źródeł przez API, preprocessing, wnioskowanie modelu AI, przetwarzanie wyników, wyzwalanie akcji. Oto praktyczny przykład łączący kilka komponentów:

import requests
import json
from datetime import datetime
import logging

class AIIntegrationPipeline:
    def __init__(self, ai_api_key, crm_api_key):
        self.ai_api_key = ai_api_key
        self.crm_api_key = crm_api_key
        self.logger = logging.getLogger(__name__)
    
    def fetch_customer_data(self, customer_id):
        """Pobierz dane klienta z API CRM"""
        headers = {'Authorization': f'Bearer {self.crm_api_key}'}
        response = requests.get(
            f'https://api.crm.example.com/customers/{customer_id}',
            headers=headers
        )
        return response.json()
    
    def analyze_with_ai(self, text_content):
        """Wyślij treść do AI do analizy"""
        headers = {
            'Authorization': f'Bearer {self.ai_api_key}',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'model': 'gpt-4',
            'messages': [
                {
                    'role': 'system',
                    'content': 'Jesteś analitykiem obsługi klienta. Przeanalizuj poniższą interakcję i podaj wnioski.'
                },
                {
                    'role': 'user',
                    'content': text_content
                }
            ],
            'temperature': 0.5,
            'max_tokens': 1000
        }
        
        response = requests.post(
            'https://api.openai.com/v1/chat/completions',
            headers=headers,
            json=payload
        )
        
        if response.status_code == 200:
            return response.json()['choices'][0]['message']['content']
        else:
            self.logger.error(f"Błąd AI API: {response.status_code}")
            raise Exception("Analiza AI nie powiodła się")
    
    def update_crm_with_insights(self, customer_id, insights):
        """Zaktualizuj CRM o wnioski AI"""
        headers = {
            'Authorization': f'Bearer {self.crm_api_key}',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'ai_insights': insights,
            'last_analyzed': datetime.now().isoformat(),
            'analysis_status': 'completed'
        }
        
        response = requests.put(
            f'https://api.crm.example.com/customers/{customer_id}',
            headers=headers,
            json=payload
        )
        
        return response.status_code == 200
    
    def process_customer(self, customer_id):
        """Pełny pipeline: pobierz, przeanalizuj, zaktualizuj"""
        try:
            # Pobierz dane klienta
            customer_data = self.fetch_customer_data(customer_id)
            
            # Przygotuj treść do analizy AI
            content_to_analyze = f"""
            Klient: {customer_data['name']}
            Ostatnie interakcje: {customer_data['recent_interactions']}
            Historia zakupów: {customer_data['purchase_history']}
            """
            
            # Uzyskaj analizę AI
            insights = self.analyze_with_ai(content_to_analyze)
            
            # Zaktualizuj CRM o wnioski
            success = self.update_crm_with_insights(customer_id, insights)
            
            if success:
                self.logger.info(f"Pomyślnie przetworzono klienta {customer_id}")
                return {'status': 'success', 'insights': insights}
            else:
                self.logger.error(f"Błąd aktualizacji CRM dla klienta {customer_id}")
                return {'status': 'error', 'message': 'Błąd aktualizacji CRM'}
        
        except Exception as e:
            self.logger.error(f"Błąd pipeline'u: {str(e)}")
            return {'status': 'error', 'message': str(e)}

Ten przykład pokazuje kompletny pipeline: pobieranie danych z CRM, analiza AI, aktualizacja CRM. Taki wzorzec można zaadaptować do wielu przypadków biznesowych.

Porównanie podejść do integracji

Różne scenariusze integracji wymagają różnych architektur. Zrozumienie kompromisów pozwala dobrać najlepszą strategię.

Każde z tych podejść ma swoje miejsce. System wsparcia klienta może używać synchronicznych wywołań API dla natychmiastowych odpowiedzi chatbota, a asynchronicznego przetwarzania dla głębszej analizy sentymentu. Platforma e-commerce może korzystać z webhooków do obsługi zamówień, a z zadań cyklicznych do nocnej analizy stanów magazynowych.

FlowHunt: Uproszczenie przepływów integracji AI

Ręczne zarządzanie wieloma integracjami API i webhookami staje się trudne wraz ze wzrostem systemu. Tu do gry wchodzi FlowHunt, całkowicie odmieniając strategię integracji.

FlowHunt to kompleksowa platforma automatyzacji, zaprojektowana specjalnie do integracji AI. Zamiast pisać i utrzymywać własny kod integracyjny, FlowHunt oferuje wizualny interfejs do łączenia modeli AI z narzędziami zewnętrznymi, zarządzania uwierzytelnianiem, obsługi błędów i monitorowania wydajności.

Kluczowe możliwości FlowHunt dla integracji AI

Wizualny kreator przepływów: Projektuj złożone przepływy integracyjne bez kodowania. Łącz modele AI, API i webhooki w intuicyjnym interfejsie drag-and-drop. FlowHunt obsługuje zaplecze HTTP, uwierzytelnianie i transformacje danych.

Gotowe konektory: FlowHunt zawiera konektory do popularnych usług AI (OpenAI, Google Cloud AI, Anthropic) i setek narzędzi zewnętrznych (Salesforce, HubSpot, Slack, Stripe i inne). Konektory obsługują szczegóły API i uwierzytelnianie, byś mógł skupić się na logice biznesowej.

Zarządzanie webhookami: FlowHunt upraszcza rejestrację i obsługę webhooków. Rejestruj webhooki, odbieraj zdarzenia, wyzwalaj analizy AI – wszystko przez interfejs FlowHunt. Nie musisz pisać własnych odbiorników.

Obsługa błędów i retry: Automatyczne ponawianie nieudanych wywołań API z wykładniczym opóźnieniem. Ustaw powiadomienia o błędach i alternatywne przepływy. FlowHunt gwarantuje odporność i niezawodność integracji.

Transformacja danych: Transformuj dane między różnymi formatami i strukturami. Mapuj pola z CRM na wejścia modelu AI, przekształcaj wyniki AI w formę oczekiwaną przez inne narzędzia.

Monitoring i logowanie: Śledź każde wywołanie API, zdarzenie webhooka i wykonanie przepływu. Identyfikuj wąskie gardła, debuguj problemy i optymalizuj wydajność dzięki pełnemu logowaniu i analityce.

Limity i throttling: FlowHunt automatycznie zarządza limitami API, kolejkowaniem i rozkładaniem żądań w czasie, by nie przekraczać limitów usług.

Przykład: Budowa przepływu analizy opinii klientów w FlowHunt

Załóżmy, że chcesz automatycznie analizować opinie klientów z systemu wsparcia, kategoryzować sentyment i aktualizować CRM. W FlowHunt taki przepływ wygląda następująco:

1. Wyzwalacz webhooka: Odbierz webhook, gdy utworzono nowe zgłoszenie supportowe
2. Pobierz dane klienta: Skorzystaj z konektora CRM, by pobrać historię klienta
3. Analiza AI: Wyślij treść zgłoszenia i historię klienta do OpenAI do analizy sentymentu i kategorii
4. Transformacja danych: Wyodrębnij wynik sentymentu i kategorię z odpowiedzi AI
5. Aktualizacja CRM: Zaktualizuj zgłoszenie w CRM o wnioski AI
6. Logika warunkowa: Jeśli sentyment negatywny – uruchom eskalację
7. Powiadomienie: Wyślij wiadomość Slack do zespołu z podsumowaniem AI

To, co w customowym rozwiązaniu wymagałoby dziesiątek linii kodu i zaawansowanej obsługi błędów, w FlowHunt staje się wizualnym przepływem. Możesz go modyfikować, dodawać kroki lub zmieniać modele AI bez dotykania kodu.

Zaawansowane wzorce integracji i dobre praktyki

W miarę rozwoju potrzeb integracyjnych AI, pewne zaawansowane wzorce i praktyki stają się kluczowe.

Limity i zarządzanie quota

Większość API narzuca limity – maksymalną liczbę żądań na minutę/godzinę. Przekroczenie limitów skutkuje błędami lub nawet blokadą usługi. Zarządzanie limitami jest krytyczne dla niezawodnej integracji.

Implementuj wykładnicze opóźnienie (exponential backoff): po otrzymaniu limitu czekaj przed ponowną próbą, stopniowo wydłużając czas oczekiwania. Większość API zwraca limity w nagłówkach odpowiedzi.

import time
import requests

def call_api_with_backoff(url, headers, data, max_retries=5):
    """Wywołanie API z wykładniczym opóźnieniem przy limitach"""
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=data)
            
            # Sprawdź limit
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 2 ** attempt))
                print(f"Przekroczono limit. Czekam {retry_after} sekund...")
                time.sleep(retry_after)
                continue
            
            response.raise_for_status()
            return response.json()
        
        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            wait_time = 2 ** attempt
            print(f"Błąd żądania: {e}. Ponawiam za {wait_time} sekund...")
            time.sleep(wait_time)
    
    raise Exception("Przekroczono maksymalną liczbę prób")

Obsługa operacji asynchronicznych

Niektóre operacje AI trwają długo. Zamiast blokować aplikację, stosuj wzorce asynchroniczne, gdzie usługa AI zwraca identyfikator zadania, a Ty odpytujesz o wynik lub czekasz na webhook.

def submit_async_ai_job(content):
    """Wyślij treść do asynchronicznej analizy AI"""
    headers = {'Authorization': f'Bearer {AI_API_KEY}'}
    
    response = requests.post(
        'https://api.ai.example.com/async-analyze',
        headers=headers,
        json={'content': content}
    )
    
    job_data = response.json()
    return job_data['job_id']

def check_job_status(job_id):
    """Sprawdź status zadania asynchronicznego"""
    headers = {'Authorization': f'Bearer {AI_API_KEY}'}
    
    response = requests.get(
        f'https://api.ai.example.com/jobs/{job_id}',
        headers=headers
    )
    
    job_data = response.json()
    
    if job_data['status'] == 'completed':
        return {'status': 'completed', 'result': job_data['result']}
    elif job_data['status'] == 'failed':
        return {'status': 'failed', 'error': job_data['error']}
    else:
        return {'status': 'processing'}

Cache’owanie i optymalizacja

Wielokrotne wysył