# Weaviate MCP MCP

> Weaviate connects your AI client directly to a vector database, allowing you to search data by meaning, not keywords. This MCP lets your agent perform deep semantic searches across massive collections of text and objects. It's built for developers needing to build production-grade applications that require understanding context—whether you’re finding similar documents or auditing cluster health.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** semantic-search, vector-embeddings, schema-management, nearest-neighbor, ai-native, data-indexing

## Description

Forget manually writing complex JSON queries in a database console just to find relevant information. This MCP hands your AI client the ability to treat your vector collection like an extension of its own memory. You can ask questions about massive data sets, and the system finds results based on context and meaning—not just keyword matching.

Your agent gains deep insight into structured metadata; it can list every class in your schema or pull specific object details using a UUID. If you're building an application that needs to connect multiple sources of truth (like pulling user data from a CRM, then checking billing status, and finally sending a message), the whole process runs through Vinkius. This means even if you need to combine this database connection with other MCPs—say, connecting it to an accounting tool—the entire workflow is secure and visible in one place.

This gives your AI agent full visibility into what every step of the data retrieval process is doing. You don't have to worry about managing credentials or tracking API calls; Vinkius handles all infrastructure and security patches, letting you focus on asking better questions.

## Tools

### get_class_schema
Gets the field definitions for one specific data collection in your database.

### get_cluster_nodes
Checks the operational status and resource usage of all nodes running your Weaviate cluster.

### get_full_schema
Retrieves a complete map of every class definition across the entire database instance.

### get_instance_metadata
Pulls high-level configuration and version details about your Weaviate environment.

### get_object_details
Looks up all the metadata and properties for a single data object using its unique identifier (UUID).

### list_objects
Lists records within a specific collection, supporting basic pagination to view multiple entries.

### search_near_vector
Performs a vector search that finds the closest matching data points based on contextual similarity.

## Prompt Examples

**Prompt:** 
```
List all classes in my Weaviate schema.
```

**Response:** 
```
I found 3 classes in your schema: 'Article', 'Product', and 'UserFeedback'. Would you like to see the property definitions for any of these classes?
```

**Prompt:** 
```
Search the 'Article' class for items similar to this vector: [0.12, -0.05, 0.88, ...].
```

**Response:** 
```
I found 5 similar articles. The top match is 'Vector Search for Beginners' (UUID: 550e8400-e29b...) with a similarity score of 0.94. Would you like to see the full content of this article?
```

**Prompt:** 
```
What is the current health status of my Weaviate cluster nodes?
```

**Response:** 
```
All 3 nodes in your cluster are currently 'HEALTHY'. Node-1 is using 42% CPU and 6.5GB RAM. Node-2 and Node-3 are also within normal operating parameters. No issues detected.
```

## Capabilities

### Search by Meaning
Find content that relates semantically to a query vector, even if the original text doesn't contain the exact words used.

### Map Data Structures
Retrieve the complete or partial schema definitions for your entire database instance, allowing you to understand what data fields exist.

### Browse Collections
List and inspect objects within specific classes, retrieving full property values and metadata.

### Deep Object Inspection
Retrieve all metadata and internal configurations for a single data object using its unique UUID.

### Monitor Cluster Health
Check the operational status, resource usage (CPU/RAM), and node health of your entire Weaviate cluster.

## Use Cases

### Finding related articles for a user profile.
A researcher needs to find documents similar to one they just read. They ask their agent to run search_near_vector using the article's vector, which surfaces five highly relevant documents without needing manual query vectors.

### Debugging a data pipeline failure.
A developer finds that an object is missing required fields. They use get_object_details by UUID to inspect the full metadata and figure out exactly what properties are wrong, saving hours of guesswork.

### Checking database connectivity for a deployment.
An SRE needs to verify if all nodes are running properly. They prompt their agent to run get_cluster_nodes, which immediately reports the CPU and RAM usage across the entire cluster.

### Listing available data types in an unknown project.
A new team member joins and needs to know what collections exist. They ask their agent to run get_class_schema or get_full_schema, getting a full list of classes without needing documentation.

## Benefits

- You can validate your entire system structure by running get_full_schema, which instantly provides a map of every class in the database without manual queries.
- Need to know if an object was correctly indexed? Use get_object_details to inspect all metadata and configurations for any given UUID. This is deep debugging power.
- Instead of keyword searches, use search_near_vector to find information based on context and meaning. It’s essential for building truly intelligent apps.
- Monitor system stability using get_cluster_nodes; you'll know immediately if a node is overloaded or failing before it causes an outage.
- When chaining this MCP with others, your agent can pull data from the database and pass that context to another service, all while Vinkius tracks usage via AI Analytics.

## How It Works

The bottom line is you use chat prompts to manage complex vector database operations without ever writing code or running manual API commands.

1. Subscribe to this MCP and provide your specific Weaviate Base URL and API Key.
2. Connect the MCP to any compatible client, like Cursor or Claude. Your agent can now access the database tools through natural conversation.
3. Ask your agent a question—for example, 'What are the available collections?' or 'Find articles about quantum computing.' The agent executes the necessary calls and returns structured data.

## Frequently Asked Questions

**How do I find similar documents using search_near_vector?**
You provide a class name and the query vector as requested. The system performs nearest neighbor searches, returning documents that are contextually most relevant to your input.

**Can get_object_details tell me what data fields exist?**
It shows the actual metadata for *one* specific object (by UUID). If you need a list of all possible fields, use get_class_schema or get_full_schema.

**What is the difference between listing and searching?**
list_objects shows every record in a class (great for browsing), but search_near_vector finds records based on *meaning* when you provide a context vector, which is much more powerful.

**What does get_cluster_nodes tell me?**
It reports the operational health of your entire cluster, showing CPU and RAM usage for every node. It’s key for monitoring performance and stability.

**When should I use `get_class_schema` instead of looking at general metadata?**
It provides the specific property definitions for a single class. Use this when your agent needs to know exactly what fields (like 'title' or 'author') exist in one particular collection before it builds a query.

**What information does `get_instance_metadata` provide about my Weaviate environment?**
This tool retrieves high-level operational details. You get the server version number, which modules are enabled, and core configuration settings. This helps confirm that your agent is connected to the expected environment.

**How does `list_objects` help me audit data in a specific collection?**
It lists individual data objects within a class, supporting pagination via limit. This lets you sample or browse existing records quickly without needing to formulate a complex vector search query.

**What is the value of running `get_full_schema`?**
This tool retrieves the complete schema for every single collection in your Weaviate instance. Use it when you need a comprehensive, global overview before deciding which data types to query.