Ako integrovať AI s externými nástrojmi pomocou API a webhookov

Úvod

Prepojenie umelej inteligencie a externých aplikácií zásadne zmenilo spôsob fungovania firiem. Dnešné podniky už nepracujú s izolovanými AI systémami – naopak, orchestrujú sofistikované integrácie, ktoré prepájajú AI modely s CRM platformami, platobnými bránami, komunikačnými nástrojmi a mnohými ďalšími službami. Tento komplexný sprievodca sa zaoberá technickými a strategickými prístupmi k integrácii AI s externými nástrojmi pomocou API a webhookov, pričom vám poskytne znalosti potrebné na vytvorenie robustných, škálovateľných a bezpečných AI workflowov.

Či už ste vývojár, ktorý buduje svoju prvú AI integráciu, alebo enterprise architekt navrhujúci komplexné automatizačné systémy, pochopenie rozdielov medzi integráciou AI cez API a webhooky je zásadné. Tento článok vás prevedie celým procesom – od základných pojmov až po pokročilé implementačné vzory – aby ste mohli s istotou pripojiť AI schopnosti k vašim existujúcim technológiám.

Čo sú API a webhooky?

Predtým, než sa pustíte do integračných stratégií, je kľúčové porozumieť základnému rozdielu medzi týmito dvoma komunikačnými paradigmatami. API (Application Programming Interface) je súbor protokolov a nástrojov, ktorý umožňuje rôznym softvérovým aplikáciám navzájom komunikovať. API fungujú na pull princípe, čo znamená, že vaša aplikácia aktívne požaduje dáta alebo služby z externého systému. Keď potrebujete informácie, iniciujete požiadavku, čakáte na odpoveď a spracujete prijaté dáta.

Naopak, webhook pracuje na push princípe. Namiesto toho, aby vaša aplikácia neustále zisťovala novinky, webhooky umožňujú externým systémom aktívne posielať dáta do vašej aplikácie pri výskyte konkrétnych udalostí. Je to ako rozdiel medzi opakovaným kontrolovaním poštovej schránky počas dňa a doručením pošty priamo k vašim dverám, keď dorazí.

API sa typicky používajú na operácie na požiadanie – získavanie informácií o používateľoch, spracovanie platieb, generovanie AI predikcií alebo získavanie dát v reálnom čase. Webhooky vynikajú v situáciách, kde je potrebná okamžitá notifikácia o udalosti: napríklad spracovanie platby, odoslanie formulára, nahranie súboru alebo špecifická akcia používateľa.

Voľba medzi API a webhookmi závisí od konkrétneho použitia. Mnohé sofistikované integrácie využívajú oba prístupy – API na získavanie dát a webhooky na prijímanie notifikácií v reálnom čase. Tento hybridný model poskytuje flexibilitu a rýchlosť, ktorú dnešné aplikácie požadujú.

Prečo je integrácia AI s externými nástrojmi dôležitá pre firmy

Podnikateľský dôvod na prepájanie AI s externými nástrojmi je presvedčivý a mnohostranný. Organizácie, ktoré úspešne implementujú tieto integrácie, získavajú významné konkurenčné výhody v rôznych oblastiach.

Prevádzková efektivita a znižovanie nákladov: Ak sú AI systémy oddelené od vašich nástrojov, vznikajú dátové silá a manuálne odovzdávanie úloh. Priama integrácia AI s CRM, emailom, projektovým riadením a ďalšími aplikáciami eliminuje tieto trenia. Namiesto manuálneho kopírovania dát AI automaticky spracuje informácie, vygeneruje poznatky a spustí akcie naprieč celou vašou technológiou. Táto automatizácia znižuje náklady, minimalizuje ľudské chyby a uvoľňuje váš tím na strategickejšie úlohy.

Rozhodovanie v reálnom čase: Webhooky umožňujú AI systémom okamžite reagovať na udalosti. Keď zákazník odosiela ticket, AI okamžite analyzuje sentiment a priradí ho správnemu tímu. Pri aktualizácii predajných dát AI ihneď prepočíta predpovede. Pri poklese zásob pod hranicu AI automaticky vygeneruje objednávku. Takáto okamžitá reakcia mení rýchlosť, akou organizácie reagujú na trh a potreby zákazníkov.

Zlepšenie zákazníckej skúsenosti: Integrované AI systémy poskytujú plynulé, personalizované zážitky. AI chatbot prepojený s CRM má prístup k histórii zákazníka a vie odpovedať kontextuálne. AI odporúčací systém v e-shope poskytuje personalizované návrhy produktov. AI asistent na plánovanie schôdzok automaticky vyhľadá voľné termíny. Tieto integrácie vytvárajú bezproblémové zážitky, ktoré si zákazníci cenia a posilňujú lojalitu.

Dáta a poznatky vo veľkom meradle: Prepojením AI s viacerými zdrojmi dát cez API môžu organizácie budovať komplexné analytické systémy, ktoré kombinujú informácie z celej prevádzky. Takýto jednotný pohľad umožňuje presnejšie predikcie, lepšie rozpoznávanie vzorcov a poznatky, ktoré by s oddelenými dátami neboli možné.

Zhrnuté hlavné benefity:

• Automatizácia opakovaných úloh naprieč viacerými platformami bez manuálneho zásahu
• Zjednotené spracovanie dát – kombinácia informácií z viacerých zdrojov pre bohatšiu AI analýzu
• Škálovateľnosť, ktorá umožňuje zvládať rastúce objemy dát a požiadaviek
• Flexibilita prispôsobiť AI workflowy s meniacimi sa požiadavkami firmy
• Súlad a auditovateľnosť cez centralizované logovanie a monitoring všetkých integrácií

Základy API pre AI integráciu

API sú základom väčšiny AI integrácií. Na efektívne prepojenie AI s externými nástrojmi je potrebné rozumieť fungovaniu API a spôsobom, ako s nimi programovo interagovať.

Typy a architektúry API

Moderné API majú rôzne podoby. Najčastejšie sa stretnete s REST (Representational State Transfer) API. Používajú štandardné HTTP metódy (GET, POST, PUT, DELETE) na operácie s resource-ami identifikovanými URL. REST API sú bezstavové – každá požiadavka obsahuje všetky informácie potrebné na jej spracovanie, čo ich robí jednoduchými na pochopenie a implementáciu.

GraphQL API poskytujú flexibilnejšiu alternatívu, kde klient žiada presne také dáta, aké potrebuje, namiesto pevne definovaných štruktúr. Je to efektívnejšie pre komplexné dotazy, no vyžaduje zložitejšiu klientskú implementáciu.

SOAP (Simple Object Access Protocol) API sú staršie, XML založené protokoly, stále používané v enterprise prostredí. Sú zložitejšie než REST, no ponúkajú robustné integračné funkcie.

RPC (Remote Procedure Call) API umožňujú volať funkcie na vzdialených serveroch ako keby boli lokálne. Niektoré blockchain a kryptomenové API využívajú tento vzor.

Pre väčšinu AI integrácií budete používať REST API, ktoré ponúkajú skvelý kompromis medzi jednoduchosťou a funkcionalitou.

Autentifikácia a bezpečnosť

Každá API interakcia vyžaduje autentifikáciu na overenie, že vaša aplikácia má oprávnenie pristupovať k službe. Poznanie autentifikačných mechanizmov je kľúčové pre bezpečnú AI integráciu.

API kľúče sú najjednoduchšou metódou. Pri registrácii pre API službu získate unikátny kľúč, ktorý prikladáte ku každej požiadavke. Hoci sú jednoduché na implementáciu, majú limity – neexpirujú automaticky a majú celo-prístup. Sú vhodné na vývoj a menej citlivé operácie, no pre produkčné systémy by nemali byť jedinou vrstvou ochrany.

OAuth 2.0 je štandard pre delegovanú autorizáciu. Namiesto priameho zdieľania prihlasovacích údajov umožňuje používateľom autorizovať vašu aplikáciu na prístup k ich dátam. Ide o bežný postup pri „pripojení účtu Google“ či „prepojení so Slackom“. OAuth je zložitejšie implementovať, ale poskytuje vyššiu bezpečnosť a kontrolu.

Bearer tokeny a JWT (JSON Web Tokens) kombinujú jednoduchosť API kľúčov s ďalšími bezpečnostnými vlastnosťami. JWT sú kryptograficky podpísané tokeny, ktoré môžu obsahovať expiračný čas, oprávnenia a ďalšie metadáta. Sú ideálne pre mikroslužby a distribuované systémy.

Obojstranné TLS (mTLS) využíva certifikáty pre overenie klienta aj servera a predstavuje najvyššiu úroveň bezpečnosti. Bežne sa používa v enterprise prostrediach a pre citlivé operácie.

Volanie API

Interakcia s API znamená tvorbu HTTP požiadaviek s príslušnými hlavičkami, parametrami a telom požiadavky. Tu je praktický príklad volania AI API:

import requests
import json

# Nastavenie autentifikácie
headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
}

# Príprava dát
data = {
    'model': 'gpt-4',
    'messages': [
        {
            'role': 'user',
            'content': 'Analyzuj túto zákaznícku spätnú väzbu na sentiment'
        }
    ],
    'temperature': 0.7,
    'max_tokens': 500,
}

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

# Spracovanie odpovede
if response.status_code == 200:
    result = response.json()
    ai_response = result['choices'][0]['message']['content']
    print(f"AI analýza: {ai_response}")
else:
    print(f"Chyba: {response.status_code} - {response.text}")

Tento príklad ukazuje základný vzor: autentifikujte sa, vytvorte požiadavku, odošlite ju na API endpoint a spracujte odpoveď. Väčšina AI integrácií sa riadi týmto vzorom, aj keď parametre a odpovede sa líšia podľa služby.

Webhook architektúra a integrácia v reálnom čase

Kým API získavajú dáta na požiadanie, webhooky umožňujú komunikáciu v reálnom čase na princípe push. Porozumieť webhook architektúre je kľúčové pre budovanie rýchlo reagujúcich AI systémov.

Ako fungujú webhooky

Webhook je v podstate spätné volanie. Zaregistrujete URL u externej služby a pri výskyte určitej udalosti táto služba odošle HTTP POST požiadavku na vašu URL s dátami o udalosti. Vaša aplikácia tieto dáta prijme, spracuje a vykoná požadovanú akciu.

Priebeh vyzerá takto:

1. Zaregistrujete webhook URL u externej služby (napr. Stripe, GitHub, Slack)
2. V danej službe nastane udalosť (platba, push kód, odoslanie správy)
3. Služba odošle HTTP POST požiadavku na vašu webhook URL s detailami udalosti
4. Vaša aplikácia prijme a spracuje webhook payload
5. Vaša aplikácia vráti odpoveď (typicky HTTP 200)
6. Vaša aplikácia vykoná akciu na základe udalosti (spustí AI analýzu, aktualizuje databázu, pošle notifikáciu)

Nastavenie webhook prijímača

Webhook prijímač je HTTP endpoint, ktorý akceptuje POST požiadavky. Tu je praktický príklad s Flaskom:

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):
    """Overenie, že webhook pochádza z dôveryhodného zdroja"""
    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():
    # Získanie raw payloadu na overenie podpisu
    payload = request.get_data()
    signature = request.headers.get('X-Signature')
    
    # Overenie pravosti webhooku
    if not verify_webhook_signature(payload, signature):
        return jsonify({'error': 'Neplatný podpis'}), 401
    
    # Spracovanie JSON dát
    data = request.json
    
    # Spracovanie udalosti
    try:
        if data['event_type'] == 'payment.completed':
            # Spustiť AI analýzu transakcie
            analyze_transaction(data['transaction_id'], data['amount'])
            
            # Aktualizovať databázu
            update_payment_status(data['transaction_id'], 'completed')
            
            # Odoslať potvrdenie
            send_confirmation_email(data['customer_email'])
        
        # Vždy vráťte 200 na potvrdenie prijatia
        return jsonify({'status': 'received'}), 200
    
    except Exception as e:
        # Zaloggovať chybu, ale vrátiť 200 kvôli retry politike
        log_error(f"Chyba pri spracovaní webhooku: {str(e)}")
        return jsonify({'status': 'received'}), 200

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

Tento príklad ukazuje dôležité postupy: overenie podpisu pre pravosť, správne ošetrenie chýb a vždy vracanie úspešnej odpovede kvôli predchádzaniu opakovaným pokusom.

Bezpečnostné aspekty webhookov

Webhooky prinášajú špecifické bezpečnostné výzvy, pretože externé služby zasielajú dáta do vašej aplikácie. Kľúčové opatrenia:

Overenie podpisu: Väčšina poskytovateľov webhookov pridáva do hlavičky podpis vypočítaný pomocou zdieľaného tajomstva. Vždy podpis overujte, aby ste sa uistili o pravosti požiadavky.

Iba HTTPS: Vždy používajte HTTPS pre webhook endpointy. Šifruje to prenos a chráni pred útokmi „man-in-the-middle“.

Whitelistovanie IP: Ak je to možné, povoľte webhooky len zo známych IP adries poskytovateľa. Zabránite tak neautorizovaným požiadavkám.

Rate Limiting: Nastavte limity na webhook endpointoch, aby ste zabránili zneužitiu alebo náhodnému preťaženiu.

Idempotencia: Navrhnite spracovanie webhookov tak, aby opakované prijatie rovnakej udalosti nespôsobilo duplicity. Dôležité, pretože poskytovatelia môžu opakovať doručenie.

Prepojenie AI modelov s externými API

Keď rozumieme základom, poďme sa pozrieť, ako prepojiť AI modely s externými službami, kde sa prejaví skutočný potenciál AI integrácie.

Výber AI služby

AI ekosystém ponúka mnoho možností s rôznymi schopnosťami, cenami a integračnými modelmi. OpenAI API sprístupňuje GPT-4, GPT-3.5 a ďalšie modely na spracovanie prirodzeného jazyka, generovanie kódu či logické úlohy. Google Cloud AI ponúka Vertex AI, Document AI aj Vision AI. AWS má SageMaker pre vlastné modely aj predpripravené služby. Anthropic Claude API sa špecializuje na bezpečné AI. Hugging Face ponúka open-source modely a model hub.

Výber závisí od požadovaných AI schopností, rozpočtu, požiadaviek na latenciu, ochrany dát a preferencie medzi manažovanými službami a self-hosted riešeniami.

Budovanie AI integračnej pipeline

Typická AI integračná pipeline zahrňuje: získavanie dát z externých zdrojov cez API, predspracovanie, AI inferenciu, spracovanie výsledkov a spúšťanie akcií. Tu je príklad komplexnej integrácie:

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):
        """Získaj dáta zákazníka z CRM API"""
        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):
        """Odošli obsah na AI API na analýzu"""
        headers = {
            'Authorization': f'Bearer {self.ai_api_key}',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'model': 'gpt-4',
            'messages': [
                {
                    'role': 'system',
                    'content': 'Ste analytik zákazníckeho servisu. Analyzujte nasledujúcu zákaznícku interakciu a poskytnite poznatky.'
                },
                {
                    '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"AI API chyba: {response.status_code}")
            raise Exception("AI analýza zlyhala")
    
    def update_crm_with_insights(self, customer_id, insights):
        """Aktualizuj CRM s AI poznatkami"""
        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):
        """Kompletná pipeline: získaj, analyzuj, aktualizuj"""
        try:
            # Získaj zákaznícke dáta
            customer_data = self.fetch_customer_data(customer_id)
            
            # Priprav obsah na AI analýzu
            content_to_analyze = f"""
            Zákazník: {customer_data['name']}
            Posledné interakcie: {customer_data['recent_interactions']}
            História nákupov: {customer_data['purchase_history']}
            """
            
            # Získaj AI analýzu
            insights = self.analyze_with_ai(content_to_analyze)
            
            # Aktualizuj CRM
            success = self.update_crm_with_insights(customer_id, insights)
            
            if success:
                self.logger.info(f"Úspešne spracovaný zákazník {customer_id}")
                return {'status': 'success', 'insights': insights}
            else:
                self.logger.error(f"Chyba pri aktualizácii CRM pre zákazníka {customer_id}")
                return {'status': 'error', 'message': 'CRM aktualizácia zlyhala'}
        
        except Exception as e:
            self.logger.error(f"Chyba pipeline: {str(e)}")
            return {'status': 'error', 'message': str(e)}

Tento príklad ukazuje kompletnú pipeline: získanie dát z CRM, odoslanie na AI analýzu a aktualizáciu CRM s výsledkami. Vzor je možné prispôsobiť mnohým biznis scenárom.

Porovnanie integračných prístupov

Rôzne scenáre vyžadujú odlišné architektúry. Poznanie kompromisov vám pomôže zvoliť správnu stratégiu.

Každý prístup má svoje miesto. Napríklad systém podpory môže používať synchrónne API volania pre okamžité odpovede chatbotu, ale asynchrónne spracovanie na hlbšiu analýzu sentimentu. E-shop môže použiť webhooky pre udalosti objednávok a plánované úlohy pre nočnú analýzu zásob.

FlowHunt: Zjednodušenie AI integračných workflowov

Spravovanie viacerých API integrácií a webhookov môže byť časom náročné. Práve tu mení FlowHunt váš prístup k integráciám.

FlowHunt je workflow automatizačná platforma špeciálne navrhnutá pre AI integrácie. Namiesto budovania vlastného kódu poskytuje vizuálne rozhranie na prepájanie AI modelov s externými nástrojmi, správu autentifikácie, ošetrenie chýb a monitoring výkonu.

Kľúčové možnosti FlowHunt pre AI integráciu

Vizuálny builder workflowov: Navrhujte komplexné integračné workflowy bez kódovania. Prepojte AI modely, API a webhooky cez intuitívne drag-and-drop rozhranie. FlowHunt sa postará o HTTP požiadavky, autentifikáciu a transformáciu dát.

Predpripravené konektory: FlowHunt obsahuje konektory pre populárne AI služby (OpenAI, Google Cloud AI, Anthropic) a stovky externých nástrojov (Salesforce, HubSpot, Slack, Stripe a ďalšie). Konektory riešia autentifikáciu a špecifiká API za vás.

Správa webhookov: FlowHunt zjednodušuje nastavenie a správu webhookov. Registrujte webhooky u externých služieb, prijímajte udalosti a spúšťajte AI analýzy – všetko cez FlowHunt. Nemusíte budovať ani udržiavať vlastných prijímačov.

Ošetrenie chýb a retry logika: Automaticky opakujte neúspešné API volania s exponenciálnym oneskorením. Nastavte notifikácie o chybách a fallback workflowy. FlowHunt zabezpečí odolnosť a spoľahlivosť integrácií.

Transformácia dát: Transformujte dáta medzi rôznymi formátmi a štruktúrami. Mapujte polia z CRM na vstupy pre AI modely a výstupy AI prevádzajte do formátov očakávaných inými nástrojmi.

Monitoring a logovanie: Sledujte každý API call, webhook udalosť a vykonanie workflowu. Identifikujte úzke miesta, debuggujte a optimalizujte výkon s komplexnou analytikou.

Rate limiting a throttle: FlowHunt automaticky manažuje limity API, radí požiadavky a distribuuje ich v čase.

Príklad: AI workflow na analýzu zákazníkov vo FlowHunt

Predstavte si, že chcete automaticky analyzovať spätnú väzbu zákazníkov zo systému podpory, kategorizovať sentiment a aktualizovať CRM. Vo FlowHunt by workflow vyzeral takto:

1. Webhook trigger: Prijatie webhooku pri vytvorení nového ticketu
2. Získanie zákazníckych dát: CRM konektor na získanie histórie zákazníka
3. AI analýza: Odoslanie obsahu ticketu a histórie do OpenAI na analýzu sentimentu a kategorizáciu
4. Transformácia dát: Extrakcia skóre sentimentu a kategórie z AI odpovede
5. Aktualizácia CRM: CRM konektor na aktualizáciu ticketu AI poznatkami
6. Podmienená logika: Ak je sentiment negatívny, spustiť workflow na eskaláciu
7. Notifikácia: Odoslanie správy do Slacku s AI zhrnutím

To, čo by vo vlastnom riešení vyžadovalo desiatky riadkov kódu a starostlivé ošetrenie chýb, sa vo FlowHunt stáva vizuálnym workflowom. Workflow môžete ľubovoľne upravovať alebo meniť AI modely bez zásahu do kódu.

Pokročilé integračné vzory a best practices

Ako vaše AI integrácie rastú, stávajú sa kľúčovými pokročilé vzory a osvedčené postupy.

Rate limiting a manažment kvót

Väčšina API má limity – maximálny počet volaní za minútu alebo hodinu. Prekročenie znamená chyby a riziko blokácie. Efektívny manažment limitov je zásadný pre spoľahlivosť.

Implementujte exponenciálne oneskorenie: pri prekročení limitu vyčkajte a zvyšujte čas čakania pri ďalších pokusoch. Väčšina API vracia informácie o limite v hlavičkách, čo umožňuje aktívne manažovať objem požiadaviek.

import time
import requests

def call_api_with_backoff(url, headers, data, max_retries=5):
    """Volanie API s exponenciálnym oneskorením pri rate limiting"""
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=data)
            
            # Skontrolujte, či ste narazili na rate limit
            if response.status_code == 429:
                # Získajte retry-after z hlavičky, ak je dostupná
                retry_after = int(response.headers.get('Retry-After', 2 ** attempt))
                print(f"Prekročený limit. Čakám {retry_after} sekúnd...")
                time.sleep(retry_after)
                continue
            
            # Iné chyby
            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"Chyba požiadavky: {e}. Opakujem o {wait_time} sekúnd...")
            time.sleep(wait_time)
    
    raise Exception("Prekročený maximálny počet pokusov")

Spracovanie asynchrónnych operácií

Niektoré AI operácie môžu trvať dlhšie. Namiesto čakania použite asynchrónne vzory, kde AI služba vráti ID úlohy a vy buď periodicky zisťujete stav, alebo prijmete webhook po dokončení.

def submit_async_ai_job(content):
    """Odošli obsah na asynchrónne AI spracovanie"""
    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):
    """Zisti stav asynchrónnej úlohy"""
    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'}

Caching a optimalizácia

Opakované volanie AI API s rovnakými vstupmi plytvá zdrojmi a zvyšuje náklady. Implementujte kešovanie výsledkov bežných dotazov.

import hashlib
import json
from functools import wraps
import redis

# Pripojenie na Redis cache
cache = redis.Redis(host='localhost', port=6379, db=0)

def cache_ai_result(ttl=3600):
    """Dekorátor na kešovanie AI výsledkov"""
    def decorator(func):
        @wraps(func)
        def wrapper(content, *args, **kwargs):
            # Vytvorenie cache kľúča z hash-u obsahu
            content_hash = hashlib