---
title: "Quickstart: Locally hosted with Docker"
description: "Weaviate is an open-source vector database built to power AI applications. This quickstart guide will show you how to:"
url: https://docs.weaviate.io/weaviate/quickstart/local
---
# Quickstart: Locally hosted with Docker
Weaviate is an open-source vector database built to power AI applications. This quickstart guide will show you how to:
1. **Set up a collection** - Create a collection and import data into it.
2. **Search** - Perform a similarity (vector) search on your data.
3. **RAG** - Perform Retrieval Augmented Generation (RAG) with a generative model.
If you encounter any issues along the way or have additional questions, use the Ask AI feature.
## Prerequisites
Before we get started, install [Docker](https://docs.docker.com/get-started/get-docker/) on your machine. We will be running Weaviate and Ollama language models locally. We recommend that you use a modern computer with at least 8GB of RAM, preferably 16GB or more.
> [!NOTE]
>
> **Telemetry**
>
> To help us improve Weaviate and understand community usage trends, Weaviate collects telemetry data by default. To learn more or opt-out, click [here](https://docs.weaviate.io/deploy/configuration/telemetry).
---
## Start Weaviate and Ollama with Docker Compose
Save the following code to a file named `docker-compose.yml` in your project directory.
```yaml
services:
weaviate:
command:
- --host
- 0.0.0.0
- --port
- '8080'
- --scheme
- http
image: cr.weaviate.io/semitechnologies/weaviate:1.40.4
ports:
- 8080:8080
- 50051:50051
volumes:
- weaviate_data:/var/lib/weaviate
restart: on-failure:0
environment:
AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
ENABLE_MODULES: 'text2vec-ollama,generative-ollama'
CLUSTER_HOSTNAME: 'node1'
depends_on:
- ollama
ollama:
image: ollama/ollama:0.12.9
ports:
- "11434:11434"
volumes:
- ollama_data:/root/.ollama
volumes:
weaviate_data:
ollama_data:
```
Run the following command to start a Weaviate instance and the Ollama server inside Docker containers:
```bash
docker compose up -d
```
Once the Ollama service starts, you can pull the required embedding model ([`nomic-embed-text`](https://ollama.com/library/nomic-embed-text)) and generative model ([`llama3.2`](https://ollama.com/library/llama3.2)) in the `ollama` container:
```bash
docker compose exec ollama ollama pull nomic-embed-text
docker compose exec ollama ollama pull llama3.2
```
---
## Install a client library
Follow the instructions below to install one of the official client libraries, available in [Python](https://docs.weaviate.io/weaviate/client-libraries/python), [JavaScript/TypeScript](https://docs.weaviate.io/weaviate/client-libraries/typescript), [Go](https://docs.weaviate.io/weaviate/client-libraries/go), and [Java](https://docs.weaviate.io/weaviate/client-libraries/java).
**Python**
```bash
pip install -U "weaviate-client[agents]"
```
**JavaScript/TypeScript**
```bash
npm install @weaviate/node @weaviate/agents
```
**Go (v5)**
```bash
go get github.com/weaviate/weaviate-go-client/v5
```
**Go (v6)**
```bash
go get github.com/weaviate/weaviate-go-client/v6
```
**Java**
```xml
io.weaviateclient66.3.1
```
**C#**
```xml
```
**Verify your setup**
Before you create anything, you can also check that the client can reach your cluster:
**Python**
quickstart\_check\_readiness.py
```py
import weaviate
client = weaviate.connect_to_local()
print(client.is_ready()) # Should print: `True`
client.close() # Free up resources
```
**JavaScript/TypeScript**
quickstart\_check\_readiness.ts
```ts
import weaviate, { WeaviateClient } from '@weaviate/node';
const client: WeaviateClient = await weaviate.connectToLocal();
var clientReadiness = await client.isReady();
console.log(clientReadiness); // Should return `true`
client.close(); // Close the client connection
```
**Go (v5)**
quickstart/1\_check\_readiness/main.go
```go
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}
// Check the connection
ready, err := client.Misc().ReadyChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", ready)
}
```
**Java**
```java
WeaviateClient client = WeaviateClient.connectToLocal();
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
```
**C#**
```csharp
using var client = await Connect.Local();
// GetMeta returns server info. A successful call indicates readiness.
var meta = await client.GetMeta();
Console.WriteLine(meta);
// The 'using' statement handles freeing up resources automatically.
```
**Curl**
```bash
curl -w "\nResponse code: %{http_code}\n" \
http://localhost:8080/v1/.well-known/ready
# You should see "Response code: 200" if the instance is ready
```
Run `docker compose ps` to confirm both containers are up. Some common first errors include:
| What you see | What it means |
| - | - |
| `Unfortunately, the gRPC health check against Weaviate could not be completed.` | The client reached REST on `8080` but not gRPC on `50051`. Check that the compose file publishes `50051:50051` and that nothing else holds the port. |
| `unauthorized: invalid api key` (HTTP 401) | The instance expects a key. The compose file above enables anonymous access, so connect without credentials, or pass the key you configured. |
| `no vectorizer found for class "Movie"` | You ran a `nearText` query against a collection that has no vectorizer. Create the collection with a vectorizer, or query with `nearVector` and supply the vector yourself. |
| A connection error naming the Ollama endpoint | Weaviate could not reach Ollama. Inside Compose the endpoint is the service name, `http://ollama:11434`, not `localhost`. Confirm you pulled the models with `docker compose exec ollama ollama pull ...`. |
| `Con004: The connection to Weaviate was not closed properly.` | The script finished without closing the client. Call `client.close()`, or use a context manager. |
---
## Step 1: Create a collection & import data
There are two paths you can choose from when importing data:
[Vectorize objects during import\
(recommended)](https://docs.weaviate.io/weaviate/quickstart/local?import=vectorization#create-a-collection): Import objects and vectorize them with the Ollama embedding model.
[Import vectors](https://docs.weaviate.io/weaviate/quickstart/local?import=custom-embeddings#create-a-collection): Import pre-computed vector embeddings along with your data.
#### Vectorize objects during import
The following example creates a collection called `Movie` with the [Ollama](https://docs.weaviate.io/weaviate/model-providers/ollama/embeddings) embedding model provider (`text2vec-ollama`) for vectorizing data during import and for querying. You are also free to use any other available [embedding model provider](https://docs.weaviate.io/weaviate/model-providers).
**Python**
```py
import weaviate
from weaviate.classes.config import Configure
# Step 1.1: Connect to your local Weaviate instance
with weaviate.connect_to_local() as client:
# Step 1.2: Create a collection
movies = client.collections.create(
name="Movie",
vector_config=Configure.Vectors.text2vec_ollama( # Configure the Ollama embedding integration
api_endpoint="http://ollama:11434", # If using Docker you might need: http://host.docker.internal:11434
model="nomic-embed-text", # The model to use
),
)
# Step 1.3: Import three objects
data_objects = [
{"title": "The Matrix", "description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers.", "genre": "Science Fiction"},
{"title": "Spirited Away", "description": "A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.", "genre": "Animation"},
{"title": "The Lord of the Rings: The Fellowship of the Ring", "description": "A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.", "genre": "Fantasy"},
]
movies = client.collections.use("Movie")
movies.data.ingest(data_objects)
print(f"Imported & vectorized {len(movies)} objects into the Movie collection")
```
**JavaScript/TypeScript**
```ts
import weaviate, { WeaviateClient, vectors } from '@weaviate/node';
// Step 1.1: Connect to your local Weaviate instance
const client: WeaviateClient = await weaviate.connectToLocal();
// Step 1.2: Create a collection
const movies = await client.collections.create({
name: 'Movie',
vectorizers: vectors.text2VecOllama({ // Configure the Ollama embedding integration
apiEndpoint: 'http://ollama:11434', // If using Docker you might need: http://host.docker.internal:11434
model: 'nomic-embed-text', // The model to use
}),
});
// Step 1.3: Import three objects
const dataObjects = [
{ title: 'The Matrix', description: 'A computer hacker learns about the true nature of reality and his role in the war against its controllers.', genre: 'Science Fiction' },
{ title: 'Spirited Away', description: 'A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.', genre: 'Animation' },
{ title: 'The Lord of the Rings: The Fellowship of the Ring', description: 'A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.', genre: 'Fantasy' },
];
const movieCollection = client.collections.get('Movie');
await movieCollection.data.ingest(
dataObjects.map((properties) => ({ properties }))
);
console.log(`Imported & vectorized ${dataObjects.length} objects into the Movie collection`);
await client.close(); // Free up resources
```
**Go (v5)**
The collection also contains a configuration for the generative (RAG) integration:
- Ollama [generative AI integrations](https://docs.weaviate.io/weaviate/model-providers/ollama/generative) for retrieval augmented generation (RAG).
```go
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
"github.com/weaviate/weaviate/entities/models"
)
func main() {
// Step 1.1: Connect to your local Weaviate instance
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client, err := weaviate.NewClient(cfg)
if err != nil {
panic(err)
}
// Step 1.2: Create a collection
classObj := &models.Class{
Class: "Movie",
Vectorizer: "text2vec-ollama",
ModuleConfig: map[string]interface{}{
"text2vec-ollama": map[string]interface{}{ // Configure the Ollama embedding integration
"apiEndpoint": "http://ollama:11434", // If using Docker you might need: http://host.docker.internal:11434
"model": "nomic-embed-text", // The model to use
},
"generative-ollama": map[string]interface{}{ // Configure the Ollama generative integration
"apiEndpoint": "http://ollama:11434", // If using Docker you might need: http://host.docker.internal:11434
"model": "llama3.2", // The model to use
},
},
}
err = client.Schema().ClassCreator().WithClass(classObj).Do(context.Background())
if err != nil {
panic(err)
}
// Step 1.3: Import three objects
dataObjects := []map[string]interface{}{
{
"title": "The Matrix",
"description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers.",
"genre": "Science Fiction",
},
{
"title": "Spirited Away",
"description": "A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.",
"genre": "Animation",
},
{
"title": "The Lord of the Rings: The Fellowship of the Ring",
"description": "A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.",
"genre": "Fantasy",
},
}
// Insert objects
objects := make([]*models.Object, len(dataObjects))
for i, obj := range dataObjects {
objects[i] = &models.Object{
Class: "Movie",
Properties: obj,
}
}
_, err = client.Batch().ObjectsBatcher().WithObjects(objects...).Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("Imported & vectorized %d objects into the Movie collection\n", len(dataObjects))
```
**Go (v6)**
> [!NOTE]
>
> **Go client `v6`**
>
> This tab uses the [`v6` Go client](https://docs.weaviate.io/weaviate/client-libraries/go). It vectorizes data with the [Ollama embedding integration](https://docs.weaviate.io/weaviate/model-providers/ollama/embeddings) (the `text2vec-ollama` module), like the other tabs. Collection-level generative (RAG) configuration is not yet available in the client, so it is omitted here (see Step 3).
```go
package main
import (
"context"
"fmt"
weaviate "github.com/weaviate/weaviate-go-client/v6"
"github.com/weaviate/weaviate-go-client/v6/collections"
"github.com/weaviate/weaviate-go-client/v6/data"
)
// The client has no typed Ollama vectorizer yet, so this small custom module
// type names text2vec-ollama. Its JSON-tagged fields are the module settings.
type text2vecOllama struct {
APIEndpoint string `json:"apiEndpoint,omitempty"`
Model string `json:"model,omitempty"`
}
func (text2vecOllama) Name() string { return "text2vec-ollama" }
func main() {
ctx := context.Background()
// Step 1.1: Connect to your local Weaviate instance.
client, err := weaviate.NewLocal(ctx)
if err != nil {
// handle error
panic(err)
}
defer client.Close()
// Step 1.2: Create a collection vectorized by the Ollama embedding integration.
if _, err := client.Collections.Create(ctx, collections.Collection{
Name: "Movie",
Properties: []collections.Property{
{Name: "title", DataType: collections.DataTypeText},
{Name: "description", DataType: collections.DataTypeText},
{Name: "genre", DataType: collections.DataTypeText},
},
Vectors: map[string]collections.VectorConfig{
"default": {Vectorizer: text2vecOllama{
APIEndpoint: "http://ollama:11434", // If using Docker you might need: http://host.docker.internal:11434
Model: "nomic-embed-text",
}},
},
}); err != nil {
// handle error
panic(err)
}
// Step 1.3: Import a few objects. The server vectorizes each one on import.
if _, err := client.Collections.Use("Movie").Data.Insert(ctx,
&data.Object{Properties: map[string]any{
"title": "The Matrix",
"description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers.",
"genre": "Science Fiction",
}},
&data.Object{Properties: map[string]any{
"title": "Spirited Away",
"description": "A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.",
"genre": "Animation",
}},
&data.Object{Properties: map[string]any{
"title": "The Lord of the Rings: The Fellowship of the Ring",
"description": "A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.",
"genre": "Fantasy",
}},
); err != nil {
// handle error
panic(err)
}
fmt.Println("Imported & vectorized 3 objects into the Movie collection")
}
```
**Java**
```java
import io.weaviate.client6.v1.api.WeaviateClient;
import io.weaviate.client6.v1.api.collections.CollectionHandle;
import io.weaviate.client6.v1.api.collections.Property;
import io.weaviate.client6.v1.api.collections.VectorConfig;
import io.weaviate.client6.v1.api.collections.WeaviateObject;
import io.weaviate.client6.v1.api.collections.batch.BatchContext;
import java.util.List;
import java.util.Map;
public class QuickstartLocalCreate {
public static void main(String[] args) throws Exception {
WeaviateClient client = null;
String collectionName = "Movie";
try {
// Step 1.1: Connect to your local Weaviate instance
client = WeaviateClient.connectToLocal();
// Step 1.2: Create a collection
client.collections.create(collectionName,
col -> col.vectorConfig(VectorConfig.text2vecOllama(v -> v
// If using Docker you might need: http://host.docker.internal:11434
.apiEndpoint("http://ollama:11434")
.model("nomic-embed-text") // The model to use
))
// Define properties for the collection
.properties(Property.text("title"), Property.text("description"),
Property.text("genre")));
// Step 1.3: Import three objects
List> dataObjects = List.of(Map.of("title",
"The Matrix", "description",
"A computer hacker learns about the true nature of reality and his role in the war against its controllers.",
"genre", "Science Fiction"),
Map.of("title", "Spirited Away", "description",
"A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.",
"genre", "Animation"),
Map.of("title", "The Lord of the Rings: The Fellowship of the Ring",
"description",
"A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.",
"genre", "Fantasy"));
// Insert the objects using server-side batching
CollectionHandle> movies =
client.collections.use(collectionName);
BatchContext> batch = movies.batch.start();
// Closing the batch sends the remaining objects and waits for the results
try (batch) {
for (Map properties : dataObjects) {
batch.add(
WeaviateObject.>of(o -> o.properties(properties)));
}
}
if (batch.numberOfErrors() > 0) {
System.err
.println("Number of failed imports: " + batch.numberOfErrors());
} else {
System.out.println("Imported & vectorized " + dataObjects.size()
+ " objects into the Movie collection");
}
} finally {
if (client != null) {
client.close(); // Free up resources
}
}
}
}
```
**C#**
```csharp
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Weaviate.Client;
using Weaviate.Client.Models;
namespace WeaviateProject.Examples
{
public class QuickstartLocalCreate
{
public static async Task Run()
{
string collectionName = "Movie";
// Step 1.1: Connect to your local Weaviate instance
var client = await Connect.Local();
// Step 1.2: Create a collection
var movies = await client.Collections.Create(
new CollectionCreateParams
{
Name = collectionName,
VectorConfig = Configure.Vector(
"default",
v =>
v.Text2VecOllama(
apiEndpoint: "http://ollama:11434",
model: "nomic-embed-text"
)
),
// Define properties for the collection
Properties =
[
Property.Text("title"),
Property.Text("description"),
Property.Text("genre"),
],
}
);
// Step 1.3: Import three objects
var dataObjects = new List