Dataobjecten importeren
Leer dataobjecten en de bijbehorende vectoren efficiënt in uw Weaviate-instantie te importeren en te beheren.
Dataobjecten importeren 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.
Gegevens importeren in Weaviate
Welkom! In deze les leer je hoe je je waardevolle gegevens in je Weaviate-instantie krijgt. Dit is een belangrijke stap voor het uitvoeren van semantische zoekopdrachten en het benutten van de krachtige mogelijkheden van Weaviate.
We behandelen hoe je afzonderlijke gegevensobjecten toevoegt en, nog belangrijker, hoe je grote gegevensverzamelingen efficiënt importeert met batchbewerkingen, inclusief het verwerken van aangepaste vectoren.
De Weaviate-client instellen
Voordat je gegevens kunt importeren, moet je met de Python-client verbinding maken met je Weaviate-instantie. Deze client is je belangrijkste interface voor interactie met de database.
Voer de onderstaande code uit om te zien hoe je verbinding maakt met een lokale Weaviate-instantie.
import weaviate
def main():
# Connect to a local Weaviate instance
# For a cloud instance, you'd use weaviate.connect_to_wcs(...)
client = weaviate.connect_to_local()
if client.is_connected():
print("Weaviate client connected successfully!")
else:
print("Failed to connect to Weaviate.")
client.close() # Always close the connection
if __name__ == "__main__":
main()Weaviate-objecten begrijpen
In Weaviate worden je gegevens opgeslagen als gegevensobjecten. Elk object hoort bij een specifieke verzameling (vergelijkbaar met een tabel of klasse) en heeft:
- Eigenschappen: Sleutel-waardeparen die je gegevens beschrijven (bijvoorbeeld een 'title' of 'content' voor een artikel).
- Vector: Een numerieke representatie (embedding) van de betekenis van het object, die wordt gebruikt voor zoekopdrachten naar overeenkomsten.
Weaviate kan deze vectoren voor je genereren, maar je kunt ook je eigen vectoren aanleveren.
Eén gegevensobject toevoegen
De eenvoudigste manier om gegevens toe te voegen is door één object tegelijk te maken. Dit is handig voor kleine hoeveelheden gegevens of tijdens het testen. Weaviate genereert automatisch een embedding voor je object op basis van de eigenschappen ervan.
In dit voorbeeld wordt ervan uitgegaan dat je een verzameling 'Article' hebt gedefinieerd (in de vorige les).
import weaviate
def main():
client = weaviate.connect_to_local()
if not client.is_connected():
print("Connection error. Exiting.")
return
article_obj = {
"title": "Introduction to Embeddings",
"content": "Embeddings convert data into numerical vectors for AI tasks."
}
try:
data_id = client.data_object.create(
properties=article_obj,
collection="Article" # Must match your schema
)
print(f"Article object created with ID: {data_id}")
except Exception as e:
print(f"Error creating object: {e}")
finally:
client.close()
if __name__ == "__main__":
main()Aangepaste vectoren opnemen
Vaak wil je embeddings gebruiken die vooraf door je eigen modellen zijn gegenereerd (bijvoorbeeld via een aanroep van een OpenAI-API). Je kunt deze aangepaste vectoren meegeven wanneer je een object maakt.
Het voorbeeld gebruikt een tijdelijke vector. In een echte toepassing zou dit een vector met veel dimensies zijn, afkomstig van een embeddingmodel.
import weaviate
def main():
client = weaviate.connect_to_local()
if not client.is_connected():
print("Connection error. Exiting.")
return
article_obj = {
"title": "Advanced RAG Techniques",
"content": "RAG systems can be enhanced with query transformations."
}
# Example custom vector (dimensions must match your collection config)
custom_vector = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
try:
data_id = client.data_object.create(
properties=article_obj,
collection="Article",
vector=custom_vector # Provide your pre-generated vector
)
print(f"Article object created with ID: {data_id}")
except Exception as e:
print(f"Error creating object: {e}")
finally:
client.close()
if __name__ == "__main__":
main()Efficiënte batchimporten
Voor grote gegevensverzamelingen is het inefficiënt om objecten één voor één te importeren vanwege de netwerkoverhead. Met de functionaliteit voor batchimport van Weaviate kun je meerdere objecten in één verzoek versturen, waardoor de prestaties sterk verbeteren.
Deze methode wordt sterk aanbevolen voor productietoepassingen en het opnemen van grote hoeveelheden gegevens.
Een eenvoudige batchimport implementeren
De client van Weaviate biedt een handige contextmanager voor batchbewerkingen. Je voegt objecten aan de batch toe en de client verwerkt het efficiënt versturen ervan.
In dit voorbeeld genereert Weaviate de vectoren voor elk artikel in de batch.
import weaviate
def main():
client = weaviate.connect_to_local()
if not client.is_connected():
print("Connection error. Exiting.")
return
articles_to_import = [
{"title": "Vector DBs Explained", "content": "Store and search vectors."},
{"title": "Pinecone vs. Weaviate", "content": "Comparing vector databases."},
{"title": "Introduction to pgvector", "content": "Vectors in PostgreSQL."}
]
try:
with client.batch as batch:
for article in articles_to_import:
batch.add_object(
properties=article,
collection="Article"
)
print(f"Successfully added {len(articles_to_import)} objects in batch.")
except Exception as e:
print(f"Error during batch import: {e}")
finally:
client.close()
if __name__ == "__main__":
main()Batchgewijs importeren met vooraf gegenereerde vectoren
Net als bij het importeren van afzonderlijke objecten kun je voor elk object aangepaste vectoren opgeven tijdens een batchimport. Dit is gebruikelijk wanneer je je gegevens al met een embeddingmodel hebt verwerkt.
Zorg ervoor dat de afmetingen van de vector overeenkomen met de configuratie van je verzameling.
import weaviate
def main():
client = weaviate.connect_to_local()
if not client.is_connected():
print("Connection error. Exiting.")
return
data_with_vectors = [
{
"properties": {"title": "AI in Healthcare", "content": "LLMs for medical research."},
"vector": [0.11, 0.22, 0.33, 0.44, 0.55, 0.66, 0.77, 0.88]
},
{
"properties": {"title": "Future of Robotics", "content": "Automation and ML."},
"vector": [0.88, 0.77, 0.66, 0.55, 0.44, 0.33, 0.22, 0.11]
}
]
try:
with client.batch as batch:
for item in data_with_vectors:
batch.add_object(
properties=item["properties"],
collection="Article",
vector=item["vector"]
)
print(f"Successfully added {len(data_with_vectors)} objects with vectors in batch.")
except Exception as e:
print(f"Error during batch import with vectors: {e}")
finally:
client.close()
if __name__ == "__main__":
main()Aanbevolen werkwijzen voor import
Zo optimaliseer je je importproces:
- Batchgrootte: Experimenteer met
batch_size(bijvoorbeeld 64, 128, 256) voor een optimale verwerkingssnelheid op basis van je netwerk en Weaviate-instantie. - Foutafhandeling: Implementeer robuuste foutafhandeling en mechanismen voor nieuwe pogingen, vooral bij grote importen die te maken kunnen krijgen met tijdelijke netwerkproblemen.
- Gegevens vooraf verwerken: Ruim je gegevens op en structureer ze voordat je ze importeert, zodat ze consistent zijn met je Weaviate-schema.
- Asynchrone importen: Overweeg voor zeer grote gegevensverzamelingen asynchrone batchbewerkingen voor nog meer efficiëntie.
Controleer je begrip
Welke van deze opties zijn voordelen van de batchimportfunctionaliteit van Weaviate in vergelijking met het één voor één importeren van objecten?
Samenvatting: gegevens importeren in Weaviate
Goed gedaan! Je hebt de essentie geleerd van het inladen van je gegevens in Weaviate:
- Hoe je met de client verbinding maakt met je Weaviate-instantie.
- De structuur van een Weaviate-gegevensobject, inclusief eigenschappen en vectoren.
- Afzonderlijke gegevensobjecten toevoegen, met of zonder aangepaste vectoren.
- Het belang en de uitvoering van efficiënte batchimporten voor grote gegevensverzamelingen.
Je bent nu klaar om je Weaviate-verzamelingen met je eigen gegevens te vullen!
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 “Dataobjecten importeren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Vectordatabases: Pinecone, Weaviate en pgvector, waaronder “Dataobjecten importeren”, 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 “Dataobjecten importeren”?
Leer dataobjecten en de bijbehorende vectoren efficiënt in uw Weaviate-instantie te importeren en te beheren. 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 “Dataobjecten importeren”?
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
- Een Weaviate-schema definiëren
- Dataobjecten importeren
- Weaviate GraphQL-query's
- Vectorizermodules en auto-embedding