Database API Key

Weaviate REST API

Open-source vector database for AI-native applications

Weaviate is an open-source vector database that enables semantic search and AI-powered applications through vector embeddings. Developers use it to build intelligent search engines, recommendation systems, and RAG (Retrieval Augmented Generation) applications with native support for multiple vectorization modules and hybrid search capabilities.

Base URL http://localhost:8080/v1

API Endpoints

Method	Endpoint	Description
GET	`/schema`	Retrieve the current database schema including all classes and their properties
POST	`/schema`	Create a new class (collection) in the database with defined properties and vectorizer settings
DELETE	`/schema/{className}`	Delete a specific class and all its objects from the database
POST	`/objects`	Create a new object in a specified class with properties and optional vector
GET	`/objects/{className}/{id}`	Retrieve a specific object by its UUID and class name
PATCH	`/objects/{className}/{id}`	Update properties of an existing object
DELETE	`/objects/{className}/{id}`	Delete a specific object from the database
POST	`/graphql`	Execute GraphQL queries for vector search, hybrid search, and data retrieval
POST	`/batch/objects`	Import multiple objects in a single batch operation for efficient data loading
GET	`/meta`	Get metadata about the Weaviate instance including version and module information
GET	`/nodes`	Retrieve information about cluster nodes in a distributed setup
POST	`/classifications`	Start a classification job using kNN or contextual classification
GET	`/classifications/{id}`	Check the status of a running or completed classification job
POST	`/objects/{className}/{id}/references/{propertyName}`	Add a cross-reference between objects in different classes
GET	`/.well-known/ready`	Health check endpoint to verify if Weaviate is ready to accept requests

Code Examples

# Create a new class (collection)
curl -X POST http://localhost:8080/v1/schema \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "class": "Article",
    "vectorizer": "text2vec-openai",
    "properties": [
      {
        "name": "title",
        "dataType": ["text"]
      },
      {
        "name": "content",
        "dataType": ["text"]
      }
    ]
  }'

# Vector search using GraphQL
curl -X POST http://localhost:8080/v1/graphql \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "query": "{ Get { Article(nearText: {concepts: [\"machine learning\"]}, limit: 5) { title content _additional { certainty distance } } } }"
  }'

// Using the Weaviate JavaScript client
const weaviate = require('weaviate-ts-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

// Create a new object
async function createArticle() {
  const result = await client.data
    .creator()
    .withClassName('Article')
    .withProperties({
      title: 'Introduction to Vector Databases',
      content: 'Vector databases enable semantic search...'
    })
    .do();
  
  console.log(result);
}

// Perform vector search
async function searchArticles() {
  const result = await client.graphql
    .get()
    .withClassName('Article')
    .withNearText({ concepts: ['machine learning'] })
    .withLimit(5)
    .withFields('title content _additional { certainty }')
    .do();
  
  console.log(result.data.Get.Article);
}

createArticle();
searchArticles();

import weaviate
from weaviate.auth import AuthApiKey

# Initialize client
client = weaviate.Client(
    url="http://localhost:8080",
    auth_client_secret=AuthApiKey(api_key="YOUR_API_KEY")
)

# Create a new class
class_schema = {
    "class": "Article",
    "vectorizer": "text2vec-openai",
    "properties": [
        {"name": "title", "dataType": ["text"]},
        {"name": "content", "dataType": ["text"]}
    ]
}
client.schema.create_class(class_schema)

# Add an object
data_object = {
    "title": "Introduction to Vector Databases",
    "content": "Vector databases enable semantic search..."
}
client.data_object.create(data_object, "Article")

# Perform vector search
result = (
    client.query
    .get("Article", ["title", "content"])
    .with_near_text({"concepts": ["machine learning"]})
    .with_limit(5)
    .with_additional(["certainty", "distance"])
    .do()
)

print(result["data"]["Get"]["Article"])

Use Weaviate from Claude / Cursor / ChatGPT

Weaviate is a self-hosted protocol — it lives on a host you operate (default http://localhost:8080/v1). A hosted MCP gateway can't reach localhost on your machine, so the usual one-click setup doesn't apply. These are the tools an MCP for Weaviate would expose:

weaviate_semantic_search Perform semantic vector search across Weaviate collections using natural language queries, returning contextually relevant results with similarity scores

weaviate_create_collection Create and configure new Weaviate collections with custom schema definitions, vectorizer modules, and indexing settings

weaviate_batch_import Import large datasets into Weaviate collections efficiently using batch operations with automatic vectorization

weaviate_hybrid_search Execute hybrid searches combining vector similarity with keyword-based BM25 ranking for optimal retrieval accuracy

weaviate_manage_schema View, update, and manage Weaviate database schemas including classes, properties, and cross-references between collections

Run an Weaviate MCP locally

The local-CLI version of these tools is on the way (npx @meru/rest-mcp --vendor=weaviate · BYO connection string · zero secrets sent to us). For now use the patterns below in your own MCP server, or self-host one from the IOX templates.

Build your own Weaviate MCP →

Weaviate REST API

API Endpoints

Sponsor this page

Code Examples

Use Weaviate from Claude / Cursor / ChatGPT

Run an Weaviate MCP locally

Related APIs