REST - /v1/objects
List all data objects​
Lists all data objects in reverse order of creation. The data will be returned as an array of objects
Method and URL​
Without any restrictions (across classes, default limit):
GET /v1/objects
With optional query params:
GET /v1/objects?class={className}&limit={limit}&include={include}
Parameters​
name | location | type |
---|---|---|
limit | URL Query Parameter (optional) | integer |
include | URL Query Parameter (optional) | string |
class | URL Query Parameter (optional) | string |
Response fields​
The response of a GET
query of a data object will give you information about all objects (or a single object). Next to general information about the data objects, like schema information and property values, meta information will be shown depending on the include
fields or additional properties
of your request.
Response format​
{
"objects": [/* list of objects, see below */],
"deprecations: null,
}
Object fields​
field name | datatype | required include or additional field | description |
---|---|---|---|
class | string | none | the class name |
creationTimeUnix | unix timestamp | none | the time stamp of creation of the data object |
id | uuid | none | the uuid of the data object |
lastUpdateTimeUnix | unix timestamp | none | the time stamp when the data object was last updated |
properties > {property_name} | dataType | none | the name and value of an individual property |
properties > {cref_property_name} > classification > closestLosingDistance | float | classification | The lowest distance of a neighbor in the losing group. Optional. If k equals the size of the winning group, there is no losing group. |
properties > {cref_property_name} > classification > closestOverallDistance | float | classification | The lowest distance of any neighbor, regardless of whether they were in the winning or losing. |
properties > {cref_property_name} > classification > closestWinningDistance | float | classification | Closest distance of a neighbor from the winning group. |
properties > {cref_property_name} > classification > losingCount | integer | classification | Size of the losing group, can be 0 if the winning group size equals k . |
properties > {cref_property_name} > classification > meanLosingDistance | float | classification | The mean distance of the losing group. It is a normalized distance (between 0 and 1), where 0 means equal and 1 would mean a perfect opposite. |
properties > {cref_property_name} > classification > meanWinningDistance | float | classification | The mean distance of the winning group. It is a normalized distance (between 0 and 1), where 0 means equal and 1 would mean a perfect opposite. |
properties > {cref_property_name} > classification > overallCount | integer | classification | Overall neighbors checked as part of the classification. In most cases this will equal k , but could be lower than k - for example if not enough data was present. |
properties > {cref_property_name} > classification > winningCount | integer | classification | Size of the winning group, a number between 1 and k . |
vector | list of floats | vector | the long vector of the location of the object in the 300 dimensional space |
classification > basedOn | string | classification | the property name where the classification was based on |
classification > classifiedFields | string | classification | the classified property |
classification > completed | timestamp | classification | the time of classification completion |
classification > id | uuid | classification | the classification id |
classification > scope | list of strings | classification | the initial fields to classify |
featureProjection > vector | list of floats | featureProjection | the 2D or 3D vector coordinates of the feature projection |
Status codes and error cases​
Cause | Description | Result |
---|---|---|
No objects present | No ?class is provided. There are no objects present in the entire Weaviate instance. | 200 OK - No error |
Valid class, no objects present | ?class is provided, class exists. There are no objects present for this class | 200 OK - No error |
Invalid class | ?class is provided, class does not exist | 404 Not Found |
Validation | Otherwise invalid user request | 422 Unprocessable Entity |
Authorization | Not allowed to view resource | 403 Forbidden |
Server-Side error | Correct user input, but request failed for another reason | 500 Internal Server Error - contains detailed error message |
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
all_objects = client.data_object.get(class_name="MyClass")
print(all_objects)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client
.data
.getter()
.withClassName('MyClass')
.withLimit(2)
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
data, err := client.Data().ObjectsGetter().
WithClassName("MyClass").
WithAdditional("classification").
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", data)
}
package technology.semi.weaviate;
import java.util.List;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Result<List<WeaviateObject>> result = client.data().objectsGetter()
.withClassName("MyClass")
.withAdditional("classification")
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl http://localhost:8080/v1/objects?limit=2&include=classification&class=MyClass
Create a data object​
Create a new data object. The provided meta-data and schema values are validated.
Performance​
💡 This endpoint is meant for individual object creations.
If you have a whole dataset that you plan on importing with Weaviate sending multiple single requests sequentially comes at a large cost:
- Each sequential request would be handled by a single thread server-side while most of the server resources are idle. In addition, if you only send the second request once the first has been completed, you will wait for a lot of network overhead.
- It's much more efficient to parallelize imports. This will minimize the connection overhead and use multiple threads server-side for indexing.
- You do not have to do the parallelization yourself, you can use the
/v1/batch
endpoint for this. Even if you are sending batches from a single client thread, the objects within a batch will be handled by multiple server threads. - Import speeds, especially for large datasets, will drastically improve when using the batching endpoint.
- Go to the
/v1/batch
endpoint.
Method and URL​
POST /v1/objects
Note: The className is not specified through the URL, as it is part of the request body.
Parameters​
The body of the data object for a new object takes the following fields:
name | type | required | description |
---|---|---|---|
class | string | yes | the class name as defined in the schema |
properties | array | yes | an object with the property values of the new data object |
properties > {property_name} | dataType | yes | the property and its value according to the set dataType |
id | v4 UUID | no | the given id of the data object |
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
data_obj = {
"name": "Jodi Kantor",
"writesFor": [{
"beacon": "weaviate://localhost/Article/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"
}]
}
data_uuid = client.data_object.create(
data_obj,
"Author",
uuid="36ddd591-2dee-4e7e-a3cc-eb86d30a4303", # optional, if not provided, one is going to be generated
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.creator()
.withClassName('Author')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.withProperties({
'name': 'Jodi Kantor',
'writesFor': [{
'beacon': 'weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80'
}]
})
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
dataSchema := map[string]interface{}{
"name": "Jodi Kantor",
"writesFor": map[string]string{
"beacon": "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80",
},
}
created, err := client.Data().Creator().
WithClassName("Author").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
WithProperties(dataSchema).
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", created)
}
package technology.semi.weaviate;
import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Map<String, Object> dataSchema = new HashMap<>();
dataSchema.put("name", "Jodi Kantor");
dataSchema.put("writesFor", new HashMap() { {
put("beacon", "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80");
} });
Result<WeaviateObject> result = client.data().creator()
.withClassName("Author")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withProperties(dataSchema)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl \
-X POST \
-H "Content-Type: application/json" \
-d '{
"class": "Author",
"id": "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
"properties": {
"name": "Jodi Kantor",
"writesFor": [{
"beacon": "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"
}]
}
}' \
http://localhost:8080/v1/objects
Create an object with geoCoordinates​
If you want to fill the value of a geoCoordinates
property, you need to specify the latitude
and longitude
as decimal degrees in floats:
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
data_obj = {
"name": "Elsevier",
"headquartersGeoLocation": {
"latitude": 52.3932696,
"longitude": 4.8374263
}
}
data_uuid = client.data_object.create(
data_obj,
"Publication",
uuid="df48b9f6-ba48-470c-bf6a-57657cb07390", # optional, if not provided, one is going to be generated
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.creator()
.withClassName('Publication')
.withId('df48b9f6-ba48-470c-bf6a-57657cb07390')
.withProperties({
'name': 'Elsevier',
'headquartersGeoLocation': {
'latitude': 52.3932696,
'longitude': 4.8374263
})
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
dataSchema := map[string]interface{}{
"name": "Elsevier",
"headquartersGeoLocation": map[string]float32{
"latitude": 52.3932696,
"longitude": 4.8374263,
},
}
created, err := client.Data().Creator().
WithClassName("Publication").
WithID("df48b9f6-ba48-470c-bf6a-57657cb07390").
WithProperties(dataSchema).
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", created)
}
package technology.semi.weaviate;
import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Map<String, Object> dataSchema = new HashMap<>();
dataSchema.put("name", "Elsevier");
dataSchema.put("headquartersGeoLocation", new HashMap() { {
put("latitude", 52.3932696f);
put("longitude", 4.8374263f);
} });
Result<WeaviateObject> result = client.data().creator()
.withClassName("Publication")
.withID("df48b9f6-ba48-470c-bf6a-57657cb07390")
.withProperties(dataSchema)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl \
-X POST \
-H "Content-Type: application/json" \
-d '{
"class": "Publication",
"id": "df48b9f6-ba48-470c-bf6a-57657cb07390",
"properties": {
"name": "Elsevier",
"headquartersGeoLocation": {
"latitude": 52.3932696,
"longitude": 4.8374263
}
}
}' \
http://localhost:8080/v1/objects
Create a data object with a custom vector​
When creating a data object, you can configure Weaviate to generate a vector with a vectorizer module, or you can provide the vector yourself. We sometimes refer to this as a "custom" vector.
You can provide a custom vector during object creation for either when:
- you are not using a vectorizer for that class, or
- you are using a vectorizer, but you wish to bypass it during the object creation stage. You can create a data object with a custom vector as follows:
- Set the
"vectorizer"
in the relevant class in the data schema.- If you are not using a vectorizer at all, configure the class accordingly. To do this, you can:
- set the default vectorizer module to
"none"
(DEFAULT_VECTORIZER_MODULE="none"
), or - set the
"vectorizer"
for the class to"none"
("vectorizer": "none"
) (note: the classvectorizer
setting will override theDEFAULT_VECTORIZER_MODULE
parameter).
- set the default vectorizer module to
- If you wish to bypass the vectorizer for object creation:
- set the vectorizer to the same vectorizer with identical settings used to generate the custom vector
Note: There is NO validation of this vector besides checking the vector length.
- set the vectorizer to the same vectorizer with identical settings used to generate the custom vector
- If you are not using a vectorizer at all, configure the class accordingly. To do this, you can:
- Then, attach the vector in a special
"vector"
field during object creation. For example, if adding a single object, you can:Note: You can set custom vectors for batch imports as well as single object creation.
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
data_obj = {
"foo": "bar"
}
data_uuid = client.data_object.create(
data_obj,
"YourClass",
uuid="36ddd591-2dee-4e7e-a3cc-eb86d30a0923", # optional, if not provided, one is going to be generated
vector = [0.3, 0.2, 0.1, .... 0.9], # supported types are `list`, `numpy.ndarray`, `torch.Tensor` and `tf.Tensor`. Make sure the length matches with your Weaviate settings.
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
const vector = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];
client.data
.creator()
.withClassName('Publication')
.withId('df48b9f6-ba48-470c-bf6a-57657cb07390')
.withProperties({
'name': 'Elsevier',
'headquartersGeoLocation': {
'latitude': 52.3932696,
'longitude': 4.8374263
})
.withVector(vector)
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
dataSchema := map[string]interface{}{
"foo": "bar",
}
vector := []float32{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}
created, err := client.Data().Creator().
WithClassName("YourClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a0923").
WithProperties(dataSchema).
WithVector(vector).
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", created)
}
package technology.semi.weaviate;
import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Map<String, Object> dataSchema = new HashMap<>();
dataSchema.put("name", "Jodi Kantor");
dataSchema.put("writesFor", new HashMap() { {
put("beacon", "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80");
} });
Float[] vector = new Float[]{0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f};
Result<WeaviateObject> result = client.data().creator()
.withClassName("Author")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withVector(vector)
.withProperties(dataSchema)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl \
-X POST \
-H "Content-Type: application/json" \
-d '{
"class": "YourClass",
"vector": [0.3, 0.2, 0.1, .... 0.9],
"properties": {
"foo": "bar",
}
}' \
http://localhost:8080/v1/objects
Learn here how you can search through custom vectors.
Get a data object​
Collect an individual data object.
Method and URL​
Available since v1.14
and preferred way:
GET /v1/objects/{className}/{id}
Available for backward compatibility and deprecated:
GET /v1/objects/{id}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{className} | URL Path | string |
{id} | URL Query param | uuid |
include | URL Query param | string |
Example request​
See here the explanation of the response fields.
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
data_object = client.data_object.get_by_id("36ddd591-2dee-4e7e-a3cc-eb86d30a4303", "MyClass")
print(data_object)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client
.data
.getterById()
.withClassName('MyClass')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
data, err := client.Data().ObjectsGetter().
WithClassName("MyClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", data)
}
package technology.semi.weaviate;
import java.util.List;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Result<List<WeaviateObject>> result = client.data().objectsGetter()
.withClassName("MyClass")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303
Example request for retrieving a data object with consistency_level=QUORUM​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
from weaviate.data.replication import ConsistencyLevel
client = weaviate.Client("http://localhost:8080")
data_object = (
client.data_object.get_by_id(
uuid="36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
class_name="MyClass",
consistency_level=ConsistencyLevel.QUORUM,
)
)
# The parameter "consistency_level" can be one of ConsistencyLevel.ALL, ConsistencyLevel.QUORUM,
# or ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is
# considered successful.
print(data_object)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client
.data
.getterById()
.withClassName('MyClass')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.withConsistencyLevel(weaviate.replication.ConsistencyLevel.QUORUM)
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
// The parameter "withConsistencyLevel" can be one of weaviate.replication.ConsistencyLevel.ALL, weaviate.replication.ConsistencyLevel.QUORUM, or weaviate.replication.ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is considered successful.
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate/data/replication"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
data, err := client.Data().ObjectsGetter().
WithClassName("MyClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
WithConsistencyLevel(replication.ConsistencyLevel.QUORUM).
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", data)
}
// The parameter "WithConsistencyLevel" can be one of weaviate.replication.ConsistencyLevel.ALL, weaviate.replication.ConsistencyLevel.QUORUM, or weaviate.replication.ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is considered successful.
package technology.semi.weaviate;
import java.util.List;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
import technology.semi.weaviate.client.v1.data.replication.model.ConsistencyLevel;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Result<List<WeaviateObject>> result = client.data().objectsGetter()
.withClassName("MyClass")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withConsistencyLevel(ConsistencyLevel.QUORUM)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
// The parameter "withConsistencyLevel" can be one of ConsistencyLevel.ALL, ConsistencyLevel.QUORUM, or ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is considered successful.
$ curl http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303?consistency_level=QUORUM
# The parameter "consistency_level" can be one of ALL, QUORUM, or ONE. Determines how many replicas must acknowledge a request before it is considered successful.
# curl /v1/objects/{className}/{id}?consistency_level=ALL
Check if a data object exists without retrieving it​
This endpoint can be used to check if a data object exists without retrieving
it. Internally it skips reading the object from disk (other than checking if
it is present), thus not using resources on marshalling, parsing, etc.
Additionally the resulting HTTP request has no body, the existence of an object
is indicated solely by the status code (204
when the object exists, 404
when it doesn't).
Method and URL​
Available since v1.14
and preferred way:
HEAD /v1/objects/{className}/{id}
Available for backward compatibility and deprecated:
HEAD /v1/objects/{id}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{className} | URL Path | string |
{id} | URL | uuid |
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
exists = client.data_object.exists("36ddd591-2dee-4e7e-a3cc-eb86d30a4303", "MyClass")
print(exists)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.checker()
.withClassName('MyClass')
.withId('df48b9f6-ba48-470c-bf6a-57657cb07390')
.do()
.then((exists) => {
console.log(exists)
})
.catch(err =>
console.error(err)
);
package main
import (
"context"
"fmt"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
exists, err := client.Data().Checker().
WithClassName("MyClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a0923").
Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", exists)
}
package technology.semi.weaviate;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Result<Boolean> result = client.data().checker()
.withClassName("MyClass")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl -I http://localhost:8080/v1/objects/MyClass/f3e20a86-0b44-4558-a336-bd137d866387
Update a data object​
Update an individual data object based on its uuid.
Method and URL​
In the RESTful API, both PUT
and PATCH
methods are accepted. PUT
replaces all property values of the data object, while PATCH
only overwrites the given properties.
Available since v1.14
and preferred way:
PUT /v1/objects/{className}/{id}
PATCH /v1/objects/{className}/{id}
Available for backward compatibility and deprecated:
PUT /v1/objects/{id}
PATCH /v1/objects/{id}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{className} | URL Path | string |
{id} | URL | uuid |
The body of the data object for a replacing (some) properties of a object takes the following fields:
name | type | required | description |
---|---|---|---|
class | string | yes | the class name as defined in the schema |
properties | array | yes | an object with the property values of the new data object |
properties > {property_name} | dataType | yes | the property and its value according to the set dataType |
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
updated_schema = {
"name": "J. Kantor"
}
# Update only the properties in variable "updated_schema"
client.data_object.update(
updated_schema,
"Author",
"36ddd591-2dee-4e7e-a3cc-eb86d30a4303"
)
# Replaces the whole data object with the "updated_schema"
client.data_object.replace(
updated_schema,
"Author",
"36ddd591-2dee-4e7e-a3cc-eb86d30a4303"
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
var className = 'Author';
var id = '36ddd591-2dee-4e7e-a3cc-eb86d30a4303';
client.data
.getterById()
.withClassName(className)
.withId(id)
.do()
.then(res => {
// alter the schema
const schema = res.schema;
schema.name = 'J. Kantor';
return client.data
.updater()
.withId(id)
.withClassName(thingClassName)
.withProperties(schema)
.do();
})
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
dataSchema := map[string]interface{}{
"name": "J. Kantor",
}
err := client.Data().Updater().
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
WithClassName("Author").
WithProperties(dataSchema).
Do(context.Background())
if err != nil {
panic(err)
}
}
package technology.semi.weaviate;
import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Map<String, Object> properties = new HashMap<>();
properties.put("name", "J. Kantor");
Result<Boolean> result = client.data().updater()
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withClassName("Author")
.withProperties(properties)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl \
-X PATCH \
-H "Content-Type: application/json" \
-d '{
"class": "Author",
"id": "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
"properties": {
"name": "J. Kantor"
}
}' \
http://localhost:8080/v1/objects/Author/36ddd591-2dee-4e7e-a3cc-eb86d30a4303
If the update was successful, no content will be returned.
Delete a data object​
Delete an individual data object from Weaviate.
Method and URL​
Available since v1.14
and preferred way:
DELETE /v1/objects/{className}/{id}
Available for backward compatibility and deprecated:
DELETE /v1/objects/{id}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{className} | URL Path | string |
{id} | URL | uuid |
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
client.data_object.delete("36ddd591-2dee-4e7e-a3cc-eb86d30a4303", "MyClass")
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.deleter()
.withClassName('MyClass')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
err := client.Data().Deleter().
WithClassName("MyClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
Do(context.Background())
if err != nil {
panic(err)
}
}
package technology.semi.weaviate;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Result<Boolean> result = client.data().deleter()
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withClassName("MyClass")
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl -X DELETE http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303
If the deletion was successful, no content will be returned.
Validate a data object​
You can validate a data object's schema and meta data.
Method and URL​
POST /v1/objects/validate
Note: As with creating an object, the className is not specified through the URL, as it is part of the request body.
Parameters​
The body of the data object for a new data object is an object taking the following field:
name | type | required | description |
---|---|---|---|
class | string | yes | the class name as defined in the schema |
properties | array | yes | an object with the property values of the new data object |
properties > {property_name} | dataType | yes | the property and its value according to the set dataType |
id | v4 uuid | no* | The id of the data object. *An ID is required by the clients. |
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
schema = {"name": "New York Times"}
valid_thing = client.data_object.validate(
schema,
"Publication",
"f81bfe5e-16ba-4615-a516-46c2ae2e5a80"
)
print(valid_thing)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
var schema = {'name': 'New York Times'};
client.data
.validator()
.withId('f81bfe5e-16ba-4615-a516-46c2ae2e5a80')
.withClassName('Publication')
.withProperties(schema)
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
dataSchema := map[string]interface{}{
"name": "New York Times",
}
err := client.Data().Validator().
WithID("f81bfe5e-16ba-4615-a516-46c2ae2e5a80").
WithClassName("Publication").
WithProperties(dataSchema).
Do(context.Background())
if err != nil {
panic(err)
}
}
package technology.semi.weaviate;
import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
Map<String, Object> dataSchema = new HashMap<>();
dataSchema.put("name", "New York Times");
Result<Boolean> result = client.data().validator()
.withID("f81bfe5e-16ba-4615-a516-46c2ae2e5a80")
.withClassName("Publication")
.withProperties(dataSchema)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl \
-X POST \
-H "Content-Type: application/json" \
-d '{
"class": "Publication",
"id": "f81bfe5e-16ba-4615-a516-46c2ae2e5a80",
"properties": {
"name": "New York Times"
}
}' \
http://localhost:8080/v1/objects/validate
If the schema of the object is valid, this request should return True
/true
in case of the clients and nothing with a plain RESTful request.
Cross-references​
Add a cross reference​
Method and URL​
Available since v1.14
and preferred way:
POST /v1/objects/{className}/{id}/references/{property_name}
Available for backward compatibility and deprecated:
POST /v1/objects/{id}/references/{property_name}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{className} | URL Path | string |
{id} | URL | uuid |
{property_name} | URL | yes |
The body of the data object for a new data object is an object taking the following field:
name | type | required | description |
---|---|---|---|
beacon | Weaviate Beacon | yes | the beacon URL of the reference, in the format of weaviate://localhost/<ClassName>/<id> |
Note: In the beacon format, you need to always use localhost
as the host,
rather than the actual hostname. localhost
refers to the fact that the
beacon's target is on the same Weaviate instance, as opposed to a foreign
instance.
Note: For backward compatibility, you can omit the class name in the beacon format and specify it as weaviate://localhost/<id>. This is, however, considered deprecated and will be removed with a future release, as duplicate IDs across classes could mean that this beacon is not uniquely identifiable.
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
# weaviate.__version__ >= 3.7.0
client = weaviate.Client("http://localhost:8080")
client.data_object.reference.add(
"36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
"wroteArticles",
"6bb06a43-e7f0-393e-9ecf-3c0f4e129064",
from_class_name="SourceClass",
to_class_name="TargetClass",
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.referenceCreator()
.withClassName('SourceClass')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.withReferenceProperty('wroteArticles')
.withReference(
client.data
.referencePayloadBuilder()
.withClassName('TargetClass')
.withId('6bb06a43-e7f0-393e-9ecf-3c0f4e129064')
.payload(),
)
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
reference := client.Data().ReferencePayloadBuilder().
WithClassName("TargetClass").
WithID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064").Payload()
err := client.Data().ReferenceCreator().
WithClassName("SourceClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
WithReferenceProperty("wroteArticles").
WithReference(reference).
Do(context.Background())
if err != nil {
panic(err)
}
}
package technology.semi.weaviate;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.SingleRef;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
SingleRef reference = client.data().referencePayloadBuilder()
.withClassName("TargetClass")
.withID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064")
.payload();
Result<Boolean> result = client.data().referenceCreator()
.withClassName("SourceClass")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withReferenceProperty("wroteArticles")
.withReference(reference)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
$ curl \
-X POST \
-H "Content-Type: application/json" \
-d '{
"beacon": "weaviate://localhost/TargetClass/6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
}
}' \
http://localhost:8080/v1/objects/SourceClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/wroteArticles
If the addition was successful, no content will be returned.
Update a cross reference​
A PUT
request updates all references of a property of a data object.
Method and URL​
Available since v1.14
and preferred way:
PUT /v1/objects/{className}/{id}/references/{property_name}
Available for backward compatibility and deprecated:
PUT /v1/objects/{id}/references/{property_name}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{className} | URL Path | string |
{id} | URL | uuid |
{property_name} | URL | yes |
The body of the data object for a new data object is a list of beacons:
name | type | required | description |
---|---|---|---|
beacon | Weaviate Beacon | yes | the beacon URL of the reference, in the format of weaviate://localhost/<ClassName>/<id> |
Note: In the beacon format, you need to always use localhost
as the host,
rather than the actual hostname. localhost
refers to the fact that the
beacon's target is on the same Weaviate instance, as opposed to a foreign
instance.
Note: For backward compatibility, you can omit the class name in the beacon format and specify it as weaviate://localhost/<id>. This is, however, considered deprecated and will be removed with a future release, as duplicate IDs across classes could mean that this beacon is not uniquely identifiable.
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
client.data_object.reference.update(
"36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
"wroteArticles",
["6bb06a43-e7f0-393e-9ecf-3c0f4e129064", "b72912b9-e5d7-304e-a654-66dc63c55b32"]
from_class_name="SourceClass",
to_class_name="TargetClass"
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.referenceReplacer()
.withClassName('SourceClass')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.withReferenceProperty('wroteArticles')
.withReferences([
client.data
.referencePayloadBuilder()
.withClassName('TargetClass')
.withId('6bb06a43-e7f0-393e-9ecf-3c0f4e129064')
.payload(),
client.data
.referencePayloadBuilder()
.withClassName('TargetClass')
.withId('b72912b9-e5d7-304e-a654-66dc63c55b32')
.payload(),
])
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
"github.com/weaviate/weaviate/entities/models"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
references := &models.MultipleRef{
client.Data().ReferencePayloadBuilder().
WithVector(vector).
WithClassName("TargetClass").
WithID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064").
Payload(),
client.Data().ReferencePayloadBuilder().
WithClassName("TargetClass").
WithID("b72912b9-e5d7-304e-a654-66dc63c55b32").
Payload(),
}
err := client.Data().ReferenceReplacer().
WithClassName("SourceClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
WithReferenceProperty("wroteArticles").
WithReferences(references).
Do(context.Background())
if err != nil {
panic(err)
}
}
package technology.semi.weaviate;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.SingleRef;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
SingleRef[] references = new SingleRef[]{
client.data().referencePayloadBuilder()
.withClassName("TargetClass")
.withID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064")
.payload(),
client.data().referencePayloadBuilder()
.withClassName("TargetClass")
.withID("b72912b9-e5d7-304e-a654-66dc63c55b32")
.payload()
};
Result<Boolean> result = client.data().referenceReplacer()
.withClassName("SourceClass")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withReferenceProperty("wroteArticles")
.withReferences(references)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
curl \
-X PUT \
-H "Content-Type: application/json" \
-d '[{
"beacon": "weaviate://localhost/TargetClass/6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
}, {
"beacon": "weaviate://localhost/TargetClass/c707d9bc-840f-3997-a09a-da6dba7d0e87"
}]
}' \
http://localhost:8080/v1/objects/SourceClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/wroteArticles
If the addition was successful, no content will be returned.
Delete a cross reference​
Delete the single reference that is given in the body from the list of references that this property of a data object has.
Method and URL​
Available since v1.14
and preferred way:
DELETE /v1/objects/{className}/{id}/references/{property_name}
Available for backward compatibility and deprecated:
DELETE /v1/objects/{id}/references/{property_name}
Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0
.
The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.
Parameters​
name | location | type |
---|---|---|
{id} | URL | uuid |
{property_name} | URL | yes |
The body of the data object for a new data object is a list of beacons:
name | type | required | description |
---|---|---|---|
beacon | Weaviate Beacon | yes | the beacon URL of the reference, in the format of weaviate://localhost/<ClassName>/<id> |
Note: In the beacon format, you need to always use localhost
as the host,
rather than the actual hostname. localhost
refers to the fact that the
beacon's target is on the same Weaviate instance, as opposed to a foreign
instance.
Note: For backward compatibility, beacons generally support an older, deprecated format without the class name, as well. This means you might find beacons with the old, deprecated format, as well as beacons with the new format in the same Weaviate instance. When deleting a reference, the beacon specified has to match the beacon to be deleted exactly. In other words, if a beacon is present using the old format (without class id) you also need to specify it the same way.
Example request​
- Python
- JavaScript
- Go
- Java
- Curl
import weaviate
client = weaviate.Client("http://localhost:8080")
client.data_object.reference.delete(
"36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
"wroteArticles",
"6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
from_class_name="SourceClass",
to_class_name="TargetClass"
)
const weaviate = require('weaviate-client');
const client = weaviate.client({
scheme: 'http',
host: 'localhost:8080',
});
client.data
.referenceDeleter()
.withClassName('SourceClass')
.withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
.withReferenceProperty('wroteArticles')
.withReference(
client.data
.referencePayloadBuilder()
.withClassName('TargetClass')
.withId('6bb06a43-e7f0-393e-9ecf-3c0f4e129064')
.payload(),
)
.do()
.then(res => {
console.log(res)
})
.catch(err => {
console.error(err)
});
package main
import (
"context"
"github.com/weaviate/weaviate-go-client/v4/weaviate"
)
func main() {
cfg := weaviate.Config{
Host: "localhost:8080",
Scheme: "http",
}
client := weaviate.New(cfg)
reference := client.Data().ReferencePayloadBuilder().
WithClassName("TargetClass").
WithID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064").Payload()
err := client.Data().ReferenceDeleter().
WithClassName("SourceClass").
WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
WithReferenceProperty("wroteArticles").
WithReference(reference).
Do(context.Background())
if err != nil {
panic(err)
}
}
package technology.semi.weaviate;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.SingleRef;
public class App {
public static void main(String[] args) {
Config config = new Config("http", "localhost:8080");
WeaviateClient client = new WeaviateClient(config);
SingleRef reference = client.data().referencePayloadBuilder()
.withClassName("TargetClass")
.withID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064")
.payload();
Result<Boolean> result = client.data().referenceDeleter()
.withClassName("SourceClass")
.withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
.withReferenceProperty("wroteArticles")
.withReference(reference)
.run();
if (result.hasErrors()) {
System.out.println(result.getError());
return;
}
System.out.println(result.getResult());
}
}
curl \
-X DELETE \
-H "Content-Type: application/json" \
-d '{
"beacon": "weaviate://localhost/TargetClass/6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
}
}' \
http://localhost:8080/v1/objects/SourceClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/wroteArticles
If the addition was successful, no content will be returned.