OpenAI ve Anthropic API'yi bir Web Uygulamasına entegre edin
Dil modeli API entegrasyonu en çok talep edilen becerilerden biridir modern web geliştirmede. İster bir chatbot oluşturmak olsun, ister bir asistan içerik oluşturma veya metin analiz sistemi, iletişim yeteneği API'leri ile etkili bir şekilde OpenAI e Antropik bu esastır.
Serinin bu dördüncü makalesinde Web Geliştiricileri için Yapay Zekadetaylı olarak inceleyeceğiz her iki API'nin eksiksiz bir web uygulamasına nasıl entegre edileceği. Yapılandırmadan başlayacağız Başlangıçta mesaj yapılarını analiz edeceğiz, yanıt akışını uygulayacağız API anahtarlarını korumak için proxy kalıplarıyla güvenli bir mimari oluşturacağız.
Ne Öğreneceksiniz
- OpenAI ve Antropik API'lerle yapılandırma ve kimlik doğrulama
- İki mesaj sistemi arasındaki yapısal farklılıkları anlayın
- Gerçek zamanlı bir deneyim için yanıt akışını uygulayın
- Hataları güçlü bir şekilde ele alın, yeniden deneyin ve hız sınırlandırın
- Jetonları sayın ve kullanım maliyetlerini optimize edin
- API anahtarlarını korumak için güvenli bir arka uç proxy oluşturun
- Akış desteğiyle eksiksiz bir sohbet arayüzü oluşturun
Seriye Genel Bakış
| # | Öğe | Odak |
|---|---|---|
| 1 | RAG'a giriş | Temel kavramlar |
| 2 | TypeScript ve LangChain ile RAG | Pratik uygulama |
| 3 | Vektör Veritabanı karşılaştırıldı | Chromadb, Çam Kozalağı, Weaviate |
| 4 | OpenAI ve Antropik API'ler (buradasınız) | API entegrasyonu |
| 5 | Ollama ile LLM Yerel | Bulutsuz yapay zeka |
| 6 | İnce ayar vs RAG | Neyi ne zaman kullanmalı |
| 7 | Yapay Zeka Aracıları | Aracı tabanlı mimari |
| 8 | CI/CD'de yapay zeka | Akıllı otomasyon |
1. API Kurulumu ve Kimlik Doğrulaması
İlk isteğinizi göndermeden önce oturum açma kimlik bilgilerinizi almalısınız. ve geliştirme ortamını doğru şekilde yapılandırın. Her iki sağlayıcı da bir Güvenli bir şekilde yönetilmesi gereken API anahtarı.
API Anahtarlarını Alın
İçin OpenAI, kayıt ol platform.openai.com ve bir anahtar oluşturun
API Anahtarları bölümünde. İçin Antropik, şu adresten konsola erişin:
console.anthropic.com ve ayarlar panelinde bir API anahtarı oluşturun.
API Anahtar Güvenliği
API anahtarlarını hiçbir zaman doğrudan kaynak koduna veya taahhüt edilen dosyalara dahil etmeyin Git'te. Her zaman ortam değişkenlerini veya gizli bir yönetim hizmetini kullanın. Açığa çıkan bir anahtar beklenmedik maliyetlere neden olabilir ve güvenliği tehlikeye atabilir.
# File .env (mai committare su Git!)
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxxxxxxxxxx
# Configurazione opzionale
OPENAI_ORG_ID=org-xxxxxxxxxxxxxxxx
OPENAI_MODEL=gpt-4o
ANTHROPIC_MODEL=claude-sonnet-4-20250514SDK'ları yükleme
Her iki sağlayıcı da TypeScript/JavaScript için bunu kolaylaştıran resmi SDK'lar sunuyor önemli ölçüde entegrasyon. SDK'lar serileştirmeyi otomatik olarak gerçekleştirir, temel seri durumdan çıkarma ve yeniden deneme.
# SDK ufficiali
npm install openai @anthropic-ai/sdk
# Gestione variabili d'ambiente
npm install dotenv
# Per il server proxy Express
npm install express cors
npm install -D @types/express @types/corsİstemci başlatma
// src/lib/ai-clients.ts
import OpenAI from 'openai';
import Anthropic from '@anthropic-ai/sdk';
import dotenv from 'dotenv';
dotenv.config();
// Client OpenAI
export const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
organization: process.env.OPENAI_ORG_ID, // opzionale
});
// Client Anthropic
export const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY,
});
// Verifica configurazione
export function validateConfig(): boolean {
if (!process.env.OPENAI_API_KEY) {
console.error('OPENAI_API_KEY non configurata');
return false;
}
if (!process.env.ANTHROPIC_API_KEY) {
console.error('ANTHROPIC_API_KEY non configurata');
return false;
}
return true;
}2. Mesaj Yapısının Karşılaştırılması
Her iki API de bir konuşmadaki mesaj kavramıyla çalışsa da, yapılar önemli ölçüde farklılık gösterir. Bu farklılıkları anlayın birleşik bir soyutlama oluşturmak için gereklidir.
Yapıların Karşılaştırılması
| karakteristik | OpenAI | Antropik |
|---|---|---|
| Mesaj rolleri | sistem, kullanıcı, asistan, araç | kullanıcı, asistan (ayrı sistem) |
| Sistem istemi | Mesajlarda | Özel parametre system |
| Modeli | model: "gpt-4o" | model: "claude-sonnet-4-20250514" |
| Maksimum çıktı | max_tokens (isteğe bağlı) | max_tokens (zorunlu) |
| Sıcaklık | 0,0 - 2,0 (varsayılan 1,0) | 0,0 - 1,0 (varsayılan 1,0) |
| Akış | Sunucu Tarafından Gönderilen Etkinlikler | Sunucu Tarafından Gönderilen Etkinlikler |
| Uç noktalar | /v1/sohbet/tamamlamalar | /v1/mesajlar |
OpenAI ile talep edildi
// src/lib/openai-chat.ts
import { openai } from './ai-clients';
interface ChatMessage {
role: 'system' | 'user' | 'assistant';
content: string;
}
export async function chatWithOpenAI(
messages: ChatMessage[],
model: string = 'gpt-4o'
): Promise<string> {
const response = await openai.chat.completions.create({
model,
messages,
temperature: 0.7,
max_tokens: 2048,
});
return response.choices[0].message.content ?? '';
}
// Esempio di utilizzo
const risposta = await chatWithOpenAI([
{ role: 'system', content: 'Sei un assistente tecnico esperto.' },
{ role: 'user', content: 'Spiega il pattern Observer in TypeScript.' },
]);
console.log(risposta);Antropik ile istek
// src/lib/anthropic-chat.ts
import { anthropic } from './ai-clients';
interface ChatMessage {
role: 'user' | 'assistant';
content: string;
}
export async function chatWithAnthropic(
messages: ChatMessage[],
systemPrompt: string = '',
model: string = 'claude-sonnet-4-20250514'
): Promise<string> {
const response = await anthropic.messages.create({
model,
max_tokens: 2048,
system: systemPrompt,
messages,
});
// Il contenuto è un array di blocchi
const textBlock = response.content.find(
(block) => block.type === 'text'
);
return textBlock?.text ?? '';
}
// Esempio di utilizzo
const risposta = await chatWithAnthropic(
[{ role: 'user', content: 'Spiega il pattern Observer in TypeScript.' }],
'Sei un assistente tecnico esperto.'
);
console.log(risposta);3. Yanıtların Akışı
Akış, kusursuz bir kullanıcı deneyimi sağlamanın anahtarıdır. Beklemek yerine mesajın tamamının oluşturulduğu, model olarak belirteçlerin gönderildiği bunları üreterek algılanan bekleme süresini büyük ölçüde azaltır.
OpenAI ile akış
// src/lib/openai-stream.ts
import { openai } from './ai-clients';
export async function* streamOpenAI(
messages: Array<{ role: string; content: string }>,
model: string = 'gpt-4o'
): AsyncGenerator<string> {
const stream = await openai.chat.completions.create({
model,
messages: messages as any,
stream: true,
temperature: 0.7,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) {
yield content;
}
}
}
// Utilizzo
async function main() {
const messages = [
{ role: 'user', content: 'Scrivi una funzione di ordinamento.' }
];
for await (const token of streamOpenAI(messages)) {
process.stdout.write(token);
}
}Anthropic ile Yayın
// src/lib/anthropic-stream.ts
import { anthropic } from './ai-clients';
export async function* streamAnthropic(
messages: Array<{ role: string; content: string }>,
systemPrompt: string = '',
model: string = 'claude-sonnet-4-20250514'
): AsyncGenerator<string> {
const stream = anthropic.messages.stream({
model,
max_tokens: 2048,
system: systemPrompt,
messages: messages as any,
});
for await (const event of stream) {
if (
event.type === 'content_block_delta' &&
event.delta.type === 'text_delta'
) {
yield event.delta.text;
}
}
}
// Utilizzo con metriche
async function main() {
const start = Date.now();
let totalTokens = 0;
for await (const token of streamAnthropic(
[{ role: 'user', content: 'Scrivi una funzione di ordinamento.' }],
'Sei un programmatore esperto.'
)) {
process.stdout.write(token);
totalTokens++;
}
console.log(`\nTempo: ${Date.now() - start}ms, Token: ${totalTokens}`);
}4. Hata Yönetimi ve Yeniden Deneme
Harici API'ler birçok nedenden dolayı başarısız olabilir: hız sınırları, zaman aşımları, sunucu hataları veya ağ sorunları. Sağlam bir yeniden deneme sistemi önemlidir Uygulamanın güvenilirliğini sağlamak için.
Yaygın Hata Kodları
| Kod | Anlam | Strateji |
|---|---|---|
| 400 | Yanlış biçimlendirilmiş istek | Tekrar denemeyin, parametreleri düzeltin |
| 401 | Kimlik doğrulama başarısız oldu | API anahtarınızı kontrol edin |
| 429 | Oran sınırı aşıldı | Lütfen bekleyin ve geri alma ile tekrar deneyin |
| 500 | Sunucu hatası | Üstel geri çekilmeyle tekrar deneyin |
| 503 | hizmet kullanılamıyor | Birkaç saniye sonra tekrar deneyin |
| 529 | Aşırı Yük (Antropik) | Uzun bir geri çekilme ile tekrar deneyin |
// src/lib/retry.ts
interface RetryConfig {
maxRetries: number;
baseDelay: number; // millisecondi
maxDelay: number; // millisecondi
backoffFactor: number;
}
const DEFAULT_CONFIG: RetryConfig = {
maxRetries: 3,
baseDelay: 1000,
maxDelay: 30000,
backoffFactor: 2,
};
export async function withRetry<T>(
fn: () => Promise<T>,
config: Partial<RetryConfig> = {}
): Promise<T> {
const cfg = { ...DEFAULT_CONFIG, ...config };
let lastError: Error | null = null;
for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
try {
return await fn();
} catch (error: any) {
lastError = error;
// Non ritentare per errori client (4xx eccetto 429)
if (error.status && error.status >= 400 &&
error.status < 500 && error.status !== 429) {
throw error;
}
if (attempt === cfg.maxRetries) break;
// Calcola il delay con jitter
const delay = Math.min(
cfg.baseDelay * Math.pow(cfg.backoffFactor, attempt) +
Math.random() * 1000,
cfg.maxDelay
);
console.warn(
`Tentativo ${attempt + 1} fallito. ` +
`Retry tra ${Math.round(delay)}ms...`
);
// Usa Retry-After se disponibile
const retryAfter = error.headers?.get?.('retry-after');
const waitTime = retryAfter
? parseInt(retryAfter) * 1000
: delay;
await new Promise(r => setTimeout(r, waitTime));
}
}
throw lastError;
}5. Hız Sınırlama ve Frekans Kontrolü
Uygulamanız çok sayıda eş zamanlı kullanıcıyı çalıştırıyorsa, uygulama çok önemlidir. uygulanan limitlerin aşılmasını önlemek için müşteri tarafı hız sınırlama sistemi sağlayıcılar tarafından sağlanması ve kaynakların adil kullanımının sağlanması.
// src/lib/rate-limiter.ts
export class TokenBucketRateLimiter {
private tokens: number;
private lastRefill: number;
constructor(
private maxTokens: number,
private refillRate: number, // token al secondo
) {
this.tokens = maxTokens;
this.lastRefill = Date.now();
}
private refill(): void {
const now = Date.now();
const elapsed = (now - this.lastRefill) / 1000;
this.tokens = Math.min(
this.maxTokens,
this.tokens + elapsed * this.refillRate
);
this.lastRefill = now;
}
async acquire(): Promise<void> {
this.refill();
if (this.tokens < 1) {
const waitTime = (1 - this.tokens) / this.refillRate * 1000;
await new Promise(r => setTimeout(r, waitTime));
this.refill();
}
this.tokens -= 1;
}
}
// Limiti per provider
const openaiLimiter = new TokenBucketRateLimiter(60, 1); // 60 RPM
const anthropicLimiter = new TokenBucketRateLimiter(50, 0.83); // 50 RPM6. Token Sayımı ve Maliyet Optimizasyonu
API maliyetleri, işlenen token sayısıyla doğru orantılıdır. Token tüketimini izlemek ve optimize etmek maliyetleri korumak için çok önemlidir özellikle yüksek trafikli uygulamalarda kontrol altında.
1 Milyon Token için Gösterge Maliyetler (Şubat 2026)
| Modeli | Giriş (1 milyon token) | Çıkış (1 milyon jeton) |
|---|---|---|
| GPT-4o | 2,50$ | 10,00$ |
| GPT-4o mini | 0,15$ | 0,60$ |
| Claude Sone 4 | 3,00$ | 15,00$ |
| Claude Haiku 3.5 | 0,80$ | 4,00$ |
Not: Fiyatlar gösterge niteliğindedir ve değişebilir. Güncellenen maliyetler için her zaman resmi belgeleri kontrol edin.
// src/lib/token-counter.ts
import { encoding_for_model } from 'tiktoken';
export class TokenCounter {
private encoder;
constructor(model: string = 'gpt-4o') {
this.encoder = encoding_for_model(model as any);
}
count(text: string): number {
return this.encoder.encode(text).length;
}
countMessages(
messages: Array<{ role: string; content: string }>
): number {
let total = 0;
for (const msg of messages) {
total += 4; // overhead per messaggio
total += this.count(msg.role);
total += this.count(msg.content);
}
total += 2; // overhead della richiesta
return total;
}
estimateCost(
inputTokens: number,
outputTokens: number,
inputCostPer1M: number,
outputCostPer1M: number
): number {
return (
(inputTokens / 1_000_000) * inputCostPer1M +
(outputTokens / 1_000_000) * outputCostPer1M
);
}
dispose(): void {
this.encoder.free();
}
}7. API Anahtar Güvenliği için Proxy Kalıbı
API anahtarlarının olması gerekmez Asla ön uca maruz kalacaksınız. Desen arasında aracı görevi görecek bir proxy sunucusu oluşturulması önerilir. kullanıcının tarayıcısı ve AI sağlayıcı API'leri. Ön uç sizinkiyle iletişim kurar sunucudur ve sunucu anahtarları güvenli bir şekilde yönetir.
// src/server/proxy.ts
import express from 'express';
import cors from 'cors';
import { openai, anthropic } from '../lib/ai-clients';
import { withRetry } from '../lib/retry';
const app = express();
app.use(cors({ origin: process.env.ALLOWED_ORIGINS?.split(',') }));
app.use(express.json());
// Middleware di rate limiting per IP
const ipRequests = new Map<string, number[]>();
function rateLimitMiddleware(
req: express.Request,
res: express.Response,
next: express.NextFunction
) {
const ip = req.ip ?? 'unknown';
const now = Date.now();
const windowMs = 60_000; // 1 minuto
const maxRequests = 20;
const requests = (ipRequests.get(ip) ?? [])
.filter(t => now - t < windowMs);
if (requests.length >= maxRequests) {
return res.status(429).json({
error: 'Troppe richieste. Riprova tra un minuto.'
});
}
requests.push(now);
ipRequests.set(ip, requests);
next();
}
app.use('/api', rateLimitMiddleware);
// Endpoint chat unificato
app.post('/api/chat', async (req, res) => {
const { provider, messages, system, model } = req.body;
try {
let content: string;
if (provider === 'openai') {
const result = await withRetry(() =>
openai.chat.completions.create({
model: model ?? 'gpt-4o',
messages,
temperature: 0.7,
})
);
content = result.choices[0].message.content ?? '';
} else {
const result = await withRetry(() =>
anthropic.messages.create({
model: model ?? 'claude-sonnet-4-20250514',
max_tokens: 2048,
system: system ?? '',
messages,
})
);
const textBlock = result.content.find(b => b.type === 'text');
content = textBlock?.text ?? '';
}
res.json({ content });
} catch (error: any) {
res.status(error.status ?? 500).json({
error: error.message ?? 'Errore interno del server'
});
}
});
app.listen(3001, () =>
console.log('Proxy AI in ascolto su porta 3001')
);8. Yanıtların Ön Uca Akışı
Akış deneyimini kullanıcının tarayıcısına getirmek için proxy sunucusu desteklemeli Sunucu Tarafından Gönderilen Etkinlikler (SSE). Bu protokol izin verir istemciye tek bir adımla artımlı olarak veri göndermek için sunucuya HTTP bağlantısı.
// src/server/stream-endpoint.ts
app.post('/api/chat/stream', async (req, res) => {
const { provider, messages, system, model } = req.body;
// Configura headers SSE
res.setHeader('Content-Type', 'text/event-stream');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('Connection', 'keep-alive');
try {
if (provider === 'openai') {
const stream = await openai.chat.completions.create({
model: model ?? 'gpt-4o',
messages,
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) {
res.write(`data: ${JSON.stringify({ content })}\n\n`);
}
}
} else {
const stream = anthropic.messages.stream({
model: model ?? 'claude-sonnet-4-20250514',
max_tokens: 2048,
system: system ?? '',
messages,
});
for await (const event of stream) {
if (
event.type === 'content_block_delta' &&
event.delta.type === 'text_delta'
) {
res.write(
`data: ${JSON.stringify({ content: event.delta.text })}\n\n`
);
}
}
}
res.write('data: [DONE]\n\n');
res.end();
} catch (error: any) {
res.write(
`data: ${JSON.stringify({ error: error.message })}\n\n`
);
res.end();
}
});Akış için Ön Uç İstemcisi
// src/app/services/ai-chat.service.ts
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
@Injectable({ providedIn: 'root' })
export class AiChatService {
private apiUrl = '/api/chat';
streamChat(
provider: 'openai' | 'anthropic',
messages: Array<{ role: string; content: string }>,
system?: string
): Observable<string> {
return new Observable(subscriber => {
const controller = new AbortController();
fetch(`${this.apiUrl}/stream`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ provider, messages, system }),
signal: controller.signal,
})
.then(response => {
const reader = response.body!.getReader();
const decoder = new TextDecoder();
function read() {
reader.read().then(({ done, value }) => {
if (done) {
subscriber.complete();
return;
}
const text = decoder.decode(value);
const lines = text.split('\n');
for (const line of lines) {
if (line.startsWith('data: ')) {
const data = line.slice(6);
if (data === '[DONE]') {
subscriber.complete();
return;
}
try {
const parsed = JSON.parse(data);
if (parsed.content) {
subscriber.next(parsed.content);
}
} catch {
// Ignora righe non parsabili
}
}
}
read();
});
}
read();
})
.catch(err => subscriber.error(err));
return () => controller.abort();
});
}
}9. Eksiksiz bir Sohbet Arayüzü Oluşturun
Şu ana kadar oluşturulmuş tüm bileşenleri birleştirerek bir arayüz oluşturabiliriz Her iki sağlayıcıyı da destekleyen tam sohbet, mesaj geçmişini yönetir ve yanıtların gerçek zamanlı akışını gösterir.
// src/app/components/chat/chat.component.ts
import { Component, signal } from '@angular/core';
import { AiChatService } from '../../services/ai-chat.service';
interface Message {
role: 'user' | 'assistant';
content: string;
provider?: string;
timestamp: Date;
}
@Component({
selector: 'app-chat',
standalone: true,
template: `...`,
})
export class ChatComponent {
messages = signal<Message[]>([]);
inputText = signal('');
isLoading = signal(false);
provider = signal<'openai' | 'anthropic'>('anthropic');
currentStream = signal('');
constructor(private chatService: AiChatService) {}
sendMessage(): void {
const text = this.inputText().trim();
if (!text || this.isLoading()) return;
// Aggiungi messaggio utente
this.messages.update(msgs => [
...msgs,
{ role: 'user', content: text, timestamp: new Date() }
]);
this.inputText.set('');
this.isLoading.set(true);
this.currentStream.set('');
// Prepara messaggi per l'API
const apiMessages = this.messages().map(m => ({
role: m.role,
content: m.content,
}));
// Avvia streaming
this.chatService.streamChat(
this.provider(),
apiMessages,
'Sei un assistente esperto e amichevole.'
).subscribe({
next: (token) => {
this.currentStream.update(s => s + token);
},
complete: () => {
this.messages.update(msgs => [
...msgs,
{
role: 'assistant',
content: this.currentStream(),
provider: this.provider(),
timestamp: new Date(),
}
]);
this.currentStream.set('');
this.isLoading.set(false);
},
error: (err) => {
console.error('Errore streaming:', err);
this.isLoading.set(false);
},
});
}
}10. En İyi Uygulamalar ve Optimizasyon
Temel entegrasyonun uygulanmasından sonra birkaç ileri düzey uygulama vardır. kaliteyi, güvenilirliği ve verimliliği önemli ölçüde artıran başvurunuzun.
Birleşik Sağlayıcı Soyutlaması
Ortak bir arayüz oluşturmak, bir sağlayıcıdan diğerine geçiş yapmanızı sağlar uygulama kodunu değiştirmeden. Bu aynı zamanda uygulamayı kolaylaştırır geri dönüş stratejileri.
// src/lib/unified-ai.ts
interface AIProvider {
chat(messages: ChatMessage[], system?: string): Promise<string>;
stream(messages: ChatMessage[], system?: string): AsyncGenerator<string>;
}
export class UnifiedAI {
private providers: Map<string, AIProvider> = new Map();
private primaryProvider: string;
constructor(primary: string) {
this.primaryProvider = primary;
}
registerProvider(name: string, provider: AIProvider): void {
this.providers.set(name, provider);
}
async chatWithFallback(
messages: ChatMessage[],
system?: string
): Promise<{ content: string; provider: string }> {
const providerOrder = [
this.primaryProvider,
...Array.from(this.providers.keys())
.filter(p => p !== this.primaryProvider)
];
for (const name of providerOrder) {
const provider = this.providers.get(name);
if (!provider) continue;
try {
const content = await withRetry(
() => provider.chat(messages, system),
{ maxRetries: 2 }
);
return { content, provider: name };
} catch (error) {
console.warn(`Provider ${name} fallito, provo il successivo...`);
}
}
throw new Error('Tutti i provider AI sono non disponibili');
}
}Kaçınılması Gereken Yaygın Hatalar
- API anahtarlarını ön uçta gösterin: her zaman bir proxy sunucusu kullan
- Hız sınırlarının göz ardı edilmesi: istemci tarafı hız sınırlayıcı uygular
- Zaman aşımlarını işlemeyin: her istek için uygun zaman aşımlarını yapılandırın
- Tüm geçmişinizi gönderin: belirteçleri kaydetmek için eski mesajları kısaltın
- Maliyetleri takip etmemek: harcama eşiklerine ilişkin uyarılar uygulayın
- Modeli sabit kodlayın: şablonu kolay güncellemeler için yapılandırılabilir hale getirin
Entegrasyon Kontrol Listesi
- API anahtarları ortam değişkenlerine kaydedilir ve hiçbir zaman koda kaydedilmez
- CORS ve hız sınırlamayla yapılandırılmış proxy sunucusu
- Üstel geri çekilme uygulanarak yeniden deneyin
- Akış her iki sağlayıcı için de çalışır
- Aktif jeton sayımı ve maliyet izleme
- Kullanıcıya yönelik bilgilendirici mesajlarla hata yönetimi
- Her iki sağlayıcı için entegrasyon testleri
- Hata ayıklama için merkezi günlük kaydı
Çözüm
OpenAI ve Antropik API'leri entegre etmek ayrıntılara dikkat etmeyi gerektirir ancak doğru şekilde yapılandırıldığında üzerine inşa edilebilecek sağlam bir temel sunar güçlü ve güvenilir yapay zeka uygulamaları. Proxy modeli anahtarlarınızı korur, yeniden deneme sistemi dayanıklılığı garanti eder ve akış bir deneyim sunar kaliteli kullanıcı
Bir sonraki makalede bunun nasıl yapılacağını inceleyeceğiz Ollama ile Yerel Yüksek Lisanslar, Buluta bağımlılığı ortadan kaldırmak ve ilginç olasılıkların önünü açmak gizlilik, maliyetler ve çevrimdışı geliştirme.