Local instances
Follow these steps to connect to a locally hosted Weaviate instance.
Local connection URL
Docker instances default to http://localhost:8080. The gRPC port, 50051, is also on localhost.
If your instance runs on Kubernetes, see the host and port values in your Helm chart's values.yaml file.
No authentication enabled
To connect to a local instance without authentication, follow these examples.
If a snippet doesn't work or you have feedback, please open a GitHub issue.
import weaviate
client = weaviate.connect_to_local()
print(client.is_ready())
import weaviate, { WeaviateClient } from '@weaviate/node';
const client = await weaviate.connectToLocal()
console.log(client)
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
)
// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
Headers: nil,
}
client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}
// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)
}
func main() {
CreateClient()
}
client, err := weaviate.NewLocal(ctx)
if err != nil {
// handle error
panic(err)
}
defer client.Close()
ready, err := client.IsReady(ctx)
if err != nil {
// handle error
panic(err)
}
fmt.Println(ready)
WeaviateClient client = WeaviateClient.connectToLocal();
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
WeaviateClient client = await Connect.Local();
var isReady = await client.IsReady();
Console.WriteLine(isReady);
curl http://localhost:8080/v1/meta | jq
Change the URL or port
To change the default URL or port number, follow these examples.
If a snippet doesn't work or you have feedback, please open a GitHub issue.
import weaviate
client = weaviate.connect_to_local(
host="127.0.0.1", # Use a string to specify the host
port=8080,
grpc_port=50051,
)
print(client.is_ready())
import weaviate, { WeaviateClient } from '@weaviate/node';
const client = await weaviate.connectToLocal(
{
host: "127.0.0.1", // URL only, no http prefix
port: 8080,
grpcPort: 50051, // Default is 50051, WCD uses 443
})
async function main() {
console.log(await client.isReady())
await client.close()
}
main()
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
)
// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
Headers: nil,
// The Go client doesn't use the gRPC port
}
client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}
// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)
}
func main() {
CreateClient()
}
client, err := weaviate.NewClient(ctx,
weaviate.WithScheme("http"),
weaviate.WithHTTPHost("127.0.0.1"),
weaviate.WithHTTPPort("8080"),
weaviate.WithGRPCHost("127.0.0.1"),
weaviate.WithGRPCPort("50051"),
)
if err != nil {
// handle error
panic(err)
}
defer client.Close()
ready, err := client.IsReady(ctx)
if err != nil {
// handle error
panic(err)
}
fmt.Println(ready)
WeaviateClient client = WeaviateClient
.connectToLocal(config -> config.host("127.0.0.1").port(8080));
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
WeaviateClient client = await WeaviateClientBuilder
.Custom(
restEndpoint: "127.0.0.1",
restPort: "8080",
grpcEndpoint: "127.0.0.1",
grpcPort: "50051",
useSsl: false
)
.BuildAsync();
var isReady = await client.IsReady();
Console.WriteLine(isReady);
curl http://localhost:8080/v1/meta | jq
# The cURL connection doesn't use the gRPC port
Authentication enabled
To authenticate with a Weaviate API key, follow these examples.
If a snippet doesn't work or you have feedback, please open a GitHub issue.
import os
import weaviate
from weaviate.classes.init import Auth
# Best practice: store your credentials in environment variables
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]
client = weaviate.connect_to_local(
auth_credentials=Auth.api_key(weaviate_api_key)
)
print(client.is_ready())
assert client.is_ready()
import weaviate, { WeaviateClient } from '@weaviate/node';
// Set this environment variable
// WEAVIATE_LOCAL_API_KEY your Weaviate instance API key
const weaviateKey = process.env.WEAVIATE_LOCAL_API_KEY as string
const client = await weaviate.connectToLocal(
{
port:8099,
grpcPort:50052,
authCredentials: new weaviate.ApiKey(weaviateKey)
}
)
console.log(client)
// Set this environment variable
// WEAVIATE_API_KEY your Weaviate instance API key
package main
import (
"context"
"fmt"
"os"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
"github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
)
// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
AuthConfig: auth.ApiKey{Value: os.Getenv("WEAVIATE_API_KEY")},
Headers: nil,
}
client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}
// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)
}
func main() {
CreateClient()
}
// Best practice: store your credentials in environment variables
client, err := weaviate.NewLocal(ctx,
weaviate.WithAPIKey(os.Getenv("WEAVIATE_API_KEY")),
)
if err != nil {
// handle error
panic(err)
}
defer client.Close()
ready, err := client.IsReady(ctx)
if err != nil {
// handle error
panic(err)
}
fmt.Println(ready)
// Best practice: store your credentials in environment variables
final String weaviateApiKey = System.getenv("WEAVIATE_LOCAL_API_KEY");
WeaviateClient client =
WeaviateClient.connectToLocal(config -> config.host("127.0.0.1")
.port(8099)
.grpcPort(50052)
.authentication(Authentication.apiKey(weaviateApiKey)));
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
// Best practice: store your credentials in environment variables
string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_LOCAL_API_KEY");
WeaviateClient client = await Connect.Local(
hostname: "127.0.0.1",
restPort: 8099,
grpcPort: 50052,
credentials: Auth.ApiKey(weaviateApiKey)
);
var isReady = await client.IsReady();
Console.WriteLine(isReady);
# Set this environment variable
# WEAVIATE_API_KEY your Weaviate instance API key
curl http://localhost:8080/v1/meta -H "Authorization: Bearer ${WEAVIATE_API_KEY}" | jq
OIDC authentication
For additional client examples, see OIDC authentication.
Third party API keys
Integrations that use external APIs often need API keys. To add third party API keys, follow these examples:
If a snippet doesn't work or you have feedback, please open a GitHub issue.
import os
import weaviate
# Best practice: store your credentials in environment variables
cohere_api_key = os.environ["COHERE_API_KEY"]
client = weaviate.connect_to_local(
headers={
"X-Cohere-Api-Key": cohere_api_key
}
)
print(client.is_ready())
import weaviate, { WeaviateClient } from '@weaviate/node';
// Set this environment variable
// COHERE_API_KEY your Cohere API key
const cohereKey = process.env.COHERE_API_KEY as string
const client = await weaviate.connectToLocal(
{
headers: {
'X-Cohere-Api-Key': cohereKey,
}
}
)
console.log(client)
// Set this environment variable
// COHERE_API_KEY your Cohere API key
package main
import (
"context"
"fmt"
"os"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
)
// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
Headers: map[string]string{
"X-Cohere-Api-Key": os.Getenv("WEAVIATE_COHERE_KEY"),
},
}
client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}
// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)
}
func main() {
CreateClient()
}
client, err := weaviate.NewLocal(ctx,
weaviate.WithHeader(http.Header{
"X-Cohere-Api-Key": []string{os.Getenv("COHERE_API_KEY")},
}),
)
if err != nil {
// handle error
panic(err)
}
defer client.Close()
ready, err := client.IsReady(ctx)
if err != nil {
// handle error
panic(err)
}
fmt.Println(ready)
// Best practice: store your credentials in environment variables
final String cohereApiKey = System.getenv("COHERE_API_KEY");
WeaviateClient client = WeaviateClient.connectToLocal(
config -> config.setHeaders(Map.of("X-Cohere-Api-Key", cohereApiKey)));
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
// Best practice: store your credentials in environment variables
string cohereApiKey = Environment.GetEnvironmentVariable("COHERE_API_KEY");
WeaviateClient client = await WeaviateClientBuilder
.Local(hostname: "localhost", restPort: 8080, grpcPort: 50051, useSsl: false)
.WithHeaders(new Dictionary<string, string> { { "X-Cohere-Api-Key", cohereApiKey } })
.BuildAsync();
var isReady = await client.IsReady();
Console.WriteLine(isReady);
# Set this environment variable
# COHERE_API_KEY your Cohere API key
curl http://localhost:8080/v1/meta \
-H 'Content-Type: application/json' \
-H "X-Cohere-Api-Key: ${COHERE_API_KEY}" | jq
Environment variables
Do not hard-code API keys or other credentials in your client code. Use environment variables or a similar secure coding technique instead.
Environment variables keep sensitive details out of your source code. Your application imports the information to runtime.
Set an environment variable.
In these examples, the environment variable names are in UPPER_CASE.
export WEAVIATE_URL="http://localhost:8080"
export WEAVIATE_API_KEY="sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz"
$Env:WEAVIATE_URL="http://localhost:8080"
$Env:WEAVIATE_API_KEY="sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz"
set WEAVIATE_URL=http://localhost:8080
set WEAVIATE_API_KEY=sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz
Import an environment variable.
If a snippet doesn't work or you have feedback, please open a GitHub issue.
weaviate_url = os.getenv("WEAVIATE_URL")
weaviate_key = os.getenv("WEAVIATE_API_KEY")
const weaviateUrl = process.env.WEAVIATE_URL;
const weaviateKey = process.env.WEAVIATE_API_KEY;
weaviateUrl := os.Getenv("WEAVIATE_URL")
weaviateKey := os.Getenv("WEAVIATE_API_KEY")
gRPC timeouts
The Python client v4 and TypeScript client v3 use gRPC. The gRPC protocol is sensitive to network delay. If you encounter connection timeouts, adjust the timeout values for initialization, queries, and insertions.
If a snippet doesn't work or you have feedback, please open a GitHub issue.
import weaviate
from weaviate.classes.init import AdditionalConfig, Timeout
client = weaviate.connect_to_local(
port=8080,
grpc_port=50051,
additional_config=AdditionalConfig(
timeout=Timeout(init=30, query=60, insert=120) # Values in seconds
)
)
print(client.is_ready())
import weaviate, { WeaviateClient } from '@weaviate/node';
const client = await weaviate.connectToLocal(
{ timeout: { init: 30, query: 60, insert: 120 }, } // Values in seconds
)
console.log(client)
WeaviateClient client =
WeaviateClient.connectToLocal(config -> config.timeout(30, 60, 120)); // Values in seconds
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
WeaviateClient client = await Connect.Local(
initTimeout: TimeSpan.FromSeconds(30),
queryTimeout: TimeSpan.FromSeconds(60),
insertTimeout: TimeSpan.FromSeconds(120)
);
var isReady = await client.IsReady();
Console.WriteLine(isReady);
Questions and feedback
Have a question or feedback? Here's how to reach us.
