Embedding-API's gebruiken
Leer services voor het genereren van embeddings van providers zoals OpenAI en Hugging Face te integreren en te gebruiken.
Embedding-API's gebruiken is een gratis Vectordatabases: Pinecone, Weaviate en pgvector-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Vectordatabases: Pinecone, Weaviate en pgvector. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Vectordatabases: Pinecone, Weaviate en pgvector bevat in totaal 4 lessen.
Wat zijn embedding-API's?
Embedding-API's zijn diensten waarmee je eenvoudig verschillende soorten gegevens, zoals tekst of afbeeldingen, kunt omzetten in vector-embeddings.
Zie ze als kant-en-klare hulpmiddelen. In plaats van je eigen complexe modellen te bouwen en te trainen, stuur je je gegevens naar de API en krijg je de numerieke vectorweergave terug.
Waarom embedding-API's gebruiken?
Een API voor embeddings gebruiken biedt aanzienlijke voordelen, vooral voor beginners of als je snel wilt integreren:
- Voorgetrainde modellen: Toegang tot krachtige, geavanceerde modellen zonder dat je ze hoeft te trainen.
- Gebruiksgemak: Eenvoudige integratie in je toepassingen met slechts enkele regels code.
- Schaalbaarheid: De API-aanbieder beheert de onderliggende infrastructuur, waardoor je toepassing eenvoudig kan meegroeien.
- Kostenefficiënt: Vaak voordeliger dan het onderhouden van je eigen modellen en hardware.
OpenAI: een toonaangevende aanbieder
OpenAI is een bekende aanbieder van AI-modellen, waaronder krachtige embeddingdiensten. Hun API maakt het eenvoudig om embeddings van hoge kwaliteit te genereren.
Een populair model dat zij aanbieden is text-embedding-ada-002. Dit model staat bekend om de goede balans tussen prestaties, veelzijdigheid en kostenefficiëntie voor veel toepassingen.
OpenAI API: eerste configuratie
Om aan de slag te gaan met de embedding-API van OpenAI heb je een API-sleutel van hun website nodig. Het is belangrijk om deze sleutel vertrouwelijk te houden!
Je moet ook de officiële Python-clientbibliotheek installeren. Open je terminal en voer het volgende uit:
pip install openaiSla je API-sleutel uit veiligheid altijd op in een omgevingsvariabele, in plaats van deze rechtstreeks in je code te zetten.
Embeddings genereren met OpenAI
Dit Python-programma laat zien hoe je met de OpenAI API een embedding voor tekst genereert. Vervang "YOUR_OPENAI_API_KEY_HERE" door je echte sleutel.
import os
from openai import OpenAI
# Replace with your actual API key or set as environment variable
# client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
client = OpenAI(api_key="YOUR_OPENAI_API_KEY_HERE") # For demonstration
def get_openai_embedding(text, model="text-embedding-ada-002"):
# OpenAI recommends replacing newlines with spaces for best results
text = text.replace("\n", " ")
response = client.embeddings.create(input=[text], model=model)
return response.data[0].embedding
if __name__ == "__main__":
example_text = "CoddyKit makes learning to code easy and fun."
embedding = get_openai_embedding(example_text)
print(f"Text: '{example_text}'")
print(f"Embedding length: {len(embedding)}")
print(f"First 5 dimensions: {embedding[:5]}")Hugging Face: opensourcemodellen
Hugging Face staat bekend om zijn uitgebreide verzameling opensource-machinemodellen. Het biedt ook een Inference API, waarmee je veel van deze modellen kunt gebruiken zonder een complexe lokale configuratie.
Dit is ideaal om met verschillende modellen te experimenteren, vooral met diverse sentence transformer-modellen die uitstekend geschikt zijn voor tekstembeddings.
Embeddings met de Hugging Face API
Je kunt de Hugging Face Inference API gebruiken met standaard-HTTP-verzoeken. Je hebt hiervoor een API-token van je Hugging Face-account nodig.
Hieronder staat een Python-voorbeeld dat de bibliotheek requests gebruikt om een embedding op te halen uit een populair sentence-transformermodel.
import requests
import json
import os
# Replace with your Hugging Face API token or set as environment variable
# HF_API_TOKEN = os.environ.get("HF_API_TOKEN")
HF_API_TOKEN = "YOUR_HUGGINGFACE_API_TOKEN_HERE" # For demonstration
# Example model for sentence embeddings
API_URL = "https://api-inference.huggingface.co/models/sentence-transformers/all-MiniLM-L6-v2"
HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"}
def query_hf_api(payload):
response = requests.post(API_URL, headers=HEADERS, json=payload)
return response.json()
if __name__ == "__main__":
text_to_embed = "Mobile learning platforms are convenient."
data = query_hf_api({"inputs": text_to_embed})
if isinstance(data, list) and len(data) > 0 and isinstance(data[0], list):
embedding = data[0]
print(f"Text: '{text_to_embed}'")
print(f"Embedding length: {len(embedding)}")
print(f"First 5 dimensions: {embedding[:5]}")
else:
print(f"Error or unexpected response: {data}")
print("Please check your API token and ensure the model is available.")Beveilig je API-sleutels!
API-sleutels zijn te vergelijken met wachtwoorden voor je services. Ga er altijd uiterst zorgvuldig mee om:
- Omgevingsvariabelen: De veiligste methode is om sleutels als omgevingsvariabelen op te slaan; zet ze nooit rechtstreeks in je code.
- Versiebeheer: Voeg API-sleutels nooit rechtstreeks toe aan je coderepository, zoals Git of GitHub.
- Toegangsbeheer: Beperk wie toegang heeft tot je API-sleutels en vervang ze regelmatig als je aanbieder dat toestaat.
Kosten en snelheidslimieten
Let bij het gebruik van embedding-API's op het volgende:
- Prijsmodellen: De meeste API's brengen kosten in rekening per verwerkt token of teken. De kosten kunnen sterk verschillen per model en aanbieder. Controleer altijd hun prijspagina's.
- Snelheidslimieten: API's beperken vaak het aantal verzoeken dat je per minuut of seconde kunt versturen. Als je deze limieten overschrijdt, kan dat leiden tot tijdelijke blokkeringen of fouten.
- Modelkeuze: Verschillende modellen bieden verschillende afwegingen tussen prestaties en kosten. Kies een model dat past bij de vereisten en het budget van je toepassing.
Voordelen van API's controleren
Welke van de volgende opties zijn belangrijke voordelen van het gebruik van een embedding-API van een externe partij, zoals OpenAI of Hugging Face, in vergelijking met het lokaal trainen van je eigen model?
Samenvatting: embedding-API's gebruiken
In deze les heb je geleerd hoe je gebruikmaakt van embeddinggeneratiediensten van aanbieders zoals OpenAI en Hugging Face:
- Je hebt de voordelen onderzocht van het gebruik van voorgetrainde modellen via API's voor gemak en schaalbaarheid.
- Je hebt praktische Python-voorbeelden gezien voor integratie met de OpenAI- en Hugging Face Inference API's om tekstembeddings te genereren.
- We hebben belangrijke aspecten besproken, zoals de beveiliging van API-sleutels, inzicht in kosten en snelheidslimieten.
Deze API's zijn krachtige hulpmiddelen om snel semantisch begrip aan je toepassingen toe te voegen, zodat je functies zoals semantisch zoeken, aanbevelingen en meer kunt bouwen!
Leer Vectordatabases: Pinecone, Weaviate en pgvector met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Embedding-API's gebruiken” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Vectordatabases: Pinecone, Weaviate en pgvector, waaronder “Embedding-API's gebruiken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Vectordatabases: Pinecone, Weaviate en pgvector bevat in totaal 4 lessen.
Wat leer ik in “Embedding-API's gebruiken”?
Leer services voor het genereren van embeddings van providers zoals OpenAI en Hugging Face te integreren en te gebruiken. Je oefent met Vectordatabases: Pinecone, Weaviate en pgvector door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Vectordatabases: Pinecone, Weaviate en pgvector te beginnen?
Ervaring vooraf is niet nodig. Vectordatabases: Pinecone, Weaviate en pgvector op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Embedding-API's gebruiken”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Vectordatabases: Pinecone, Weaviate en pgvector?
Ja. Elke les over Vectordatabases: Pinecone, Weaviate en pgvector bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Modellen voor text embeddings
- Embedding-API's gebruiken
- Embeddings opslaan en bijwerken
- Tekst chunken voor betere embeddings