Elasticsearch vector and full-text search in 10 minutes

export ES_URL="<YOUR_PROJECT_URL>"
export ES_API_KEY="YOUR_API_KEY"
		

1. For example, https://my-project.es.us-east-1.aws.elastic.cloud:443.

$Env:ES_URL = "<YOUR_PROJECT_URL>"
$Env:ES_API_KEY = "YOUR_API_KEY"
		

1. For example, https://my-project.es.us-east-1.aws.elastic.cloud:443.

pip install elasticsearch
		

For supported Python versions and other requirements, refer to the Python client documentation.

npm install @elastic/elasticsearch
npm install --save-dev typescript tsx
npm pkg set type=module
		

For supported Node.js versions and other requirements, refer to the JavaScript client documentation.

composer require elasticsearch/elasticsearch
		

For supported PHP versions and other requirements, refer to the PHP client documentation.

bundle add elasticsearch
		

For supported Ruby versions and other requirements, refer to the Ruby client installation documentation.

dotnet add package Elastic.Clients.Elasticsearch
		

For supported .NET versions and other requirements, refer to the .NET client documentation.

Add the client dependency and the runnable example's main class to the generated build.gradle file:

dependencies {
    implementation "co.elastic.clients:elasticsearch-java:VERSION"
}

application {
    mainClass = "quickstart.App"
}
		

Replace VERSION with the version from the latest Java client release. For supported Java versions and other requirements, refer to the Java client documentation.

go get github.com/elastic/go-elasticsearch/v9
		

For supported Go versions and other requirements, refer to the Go client installation documentation.

es.indices.create(
    index="books",
    mappings={
        "properties": {
            "description": {
                "type": "semantic_text",
            }
        }
    },
)
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. semantic_text automatically embeds text at ingest time using an inference endpoint. The inference endpoint connects to an embedding model that converts indexed text and search queries into vectors.
   In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.
   
   

await es.indices.create({
  index: "books",
  mappings: {
    properties: {
      description: {
        type: "semantic_text",
      },
    },
  },
});
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

$es->indices()->create([
    "index" => "books",
    "body" => [
        "mappings" => [
            "properties" => [
                "description" => [
                    "type" => "semantic_text",
                ],
            ],
        ],
    ],
]);
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

es.indices.create(
  index: "books",
  body: {
    mappings: {
      properties: {
        description: {
          type: "semantic_text"
        }
      }
    }
  }
)
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

await es.Indices.CreateAsync<Book>("books", c => c
    .Mappings(m => m
        .Properties(p => p
            .SemanticText(b => b.Description)
        )
    )
);
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

es.indices().create(c -> c
    .index("books")
    .withJson(new StringReader("""
        {
          "mappings": {
            "properties": {
              "description": {
                "type": "semantic_text"
              }
            }
          }
        }
        """))
);
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

createResponse, err := es.Indices.Create(
	"books",
	es.Indices.Create.WithBody(strings.NewReader(`{
	  "mappings": {
	    "properties": {
	      "description": {
	        "type": "semantic_text"
	      }
	    }
	  }
	}`)),
)
if err != nil {
	panic(err)
}
if createResponse.IsError() {
	log.Fatal(createResponse)
}
createResponse.Body.Close()
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

				PUT books
					{
  "mappings": {
    "properties": {
      "description": {
        "type": "semantic_text"
      }
    }
  }
}
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.
   semantic_text automatically embeds text at ingest time using an inference endpoint. The inference endpoint connects to an embedding model that converts indexed text and search queries into vectors.

curl -X PUT "$ES_URL/books" \
  -H "Authorization: ApiKey $ES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "mappings": {
      "properties": {
        "description": {
          "type": "semantic_text"
        }
      }
    }
  }'
		

1. Elasticsearch uses dynamic mapping to determine field types from the first documents you index. The only field you need to define is description, which you set to semantic_text before indexing so you can search it by meaning.
2. In this example, semantic_text uses a default inference endpoint. The model used by this endpoint is multilingual, so you can index and search text in multiple languages. You can also configure inference endpoints for semantic_text to use custom models.

resp = es.search(
    index="books",
    query={
        "bool": {
            "should": [
                {
                    "match": {
                        "title": "wind"
                    }
                },
                {
                    "semantic": {
                        "field": "description",
                        "query": "young magician coming of age",
                    }
                },
            ]
        }
    },
)

for hit in resp["hits"]["hits"]:
    print(hit["_score"], hit["_source"]["title"])
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

const resp = await es.search<Book>({
  index: "books",
  query: {
    bool: {
      should: [
        {
          match: {
            title: "wind",
          },
        },
        {
          semantic: {
            field: "description",
            query: "young magician coming of age",
          },
        },
      ],
    },
  },
});

for (const hit of resp.hits.hits) {
  console.log(hit._score, hit._source?.title);
}
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

$response = $es->search([
    "index" => "books",
    "body" => [
        "query" => [
            "bool" => [
                "should" => [
                    [
                        "match" => [
                            "title" => "wind",
                        ],
                    ],
                    [
                        "semantic" => [
                            "field" => "description",
                            "query" => "young magician coming of age",
                        ],
                    ],
                ],
            ],
        ],
    ],
]);

foreach ($response["hits"]["hits"] as $hit) {
    echo $hit["_score"] . " " . $hit["_source"]["title"] . "\n";
}
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

response = es.search(
  index: "books",
  body: {
    query: {
      bool: {
        should: [
          {
            match: {
              title: "wind"
            }
          },
          {
            semantic: {
              field: "description",
              query: "young magician coming of age"
            }
          }
        ]
      }
    }
  }
)

response["hits"]["hits"].each do |hit|
  puts "#{hit["_score"]} #{hit["_source"]["title"]}"
end
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

var response = await es.SearchAsync<SearchBook>(s => s
    .Indices("books")
    .Query(q => q
        .Bool(b => b
            .Should(
                should => should
                    .Match(match => match
                        .Field(book => book.Title)
                        .Query("wind")
                    ),
                should => should
                    .Semantic(semantic => semantic
                        .Field("description")
                        .Query("young magician coming of age")
                    )
            )
        )
    )
);

foreach (var hit in response.Hits)
{
    Console.WriteLine($"{hit.Score} {hit.Source?.Title}");
}
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

String query = """
    {
      "query": {
        "bool": {
          "should": [
            {
              "match": {
                "title": "wind"
              }
            },
            {
              "semantic": {
                "field": "description",
                "query": "young magician coming of age"
              }
            }
          ]
        }
      }
    }
    """;

SearchResponse<Book> response = es.search(s -> s
        .index("books")
        .withJson(new StringReader(query)),
    Book.class
);

for (Hit<Book> hit : response.hits().hits()) {
    System.out.println(hit.score() + " " + hit.source().title());
}
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

query := strings.NewReader(`{
	  "query": {
	    "bool": {
	      "should": [
	        {
	          "match": {
	            "title": "wind"
	          }
	        },
	        {
	          "semantic": {
	            "field": "description",
	            "query": "young magician coming of age"
	          }
	        }
	      ]
	    }
	  }
	}`)

	res, err := es.Search(
		es.Search.WithContext(context.Background()),
		es.Search.WithIndex("books"),
		es.Search.WithBody(query),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	if res.IsError() {
		log.Fatal(res)
	}

	var response struct {
		Hits struct {
			Hits []struct {
				Score  float64 `json:"_score"`
				Source struct {
					Title string `json:"title"`
				} `json:"_source"`
			} `json:"hits"`
		} `json:"hits"`
	}
	if err := json.NewDecoder(res.Body).Decode(&response); err != nil {
		log.Fatal(err)
	}

for _, hit := range response.Hits.Hits {
	fmt.Println(hit.Score, hit.Source.Title)
}
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

				GET books/_search
					{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "title": "wind"
          }
        },
        {
          "semantic": {
            "field": "description",
            "query": "young magician coming of age"
          }
        }
      ]
    }
  }
}
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.

curl -X GET "$ES_URL/books/_search" \
  -H "Authorization: ApiKey $ES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": {
      "bool": {
        "should": [
          {
            "match": {
              "title": "wind"
            }
          },
          {
            "semantic": {
              "field": "description",
              "query": "young magician coming of age"
            }
          }
        ]
      }
    }
  }'
		

1. The match clause performs full-text search on title and scores how well the analyzed text matches wind.
2. The semantic clause searches description by meaning and contributes its semantic similarity score.