Upstash Vector

https://upstash.com/docs/vector
Admin
Upstash Vector is a serverless vector database that enables developers to store, index, and query...
Tokens:118,539
Snippets:919
Trust Score:10
Update:6 days ago
Show doc for...
Tokens:
Raw
### Quick example (sync)

Source: https://upstash.com/docs/vector/sdks/py/example_calls/resumable-query

Starts a resumable query with a vector, retrieves the initial batch, and fetches more results using the handle. The handle is stopped automatically when the context block exits.

```python
from upstash_vector import Index
index = Index()
# start a resumable query (returns initial results and a handle)
results, handle = index.resumable_query(
    vector=[0.1, 0.2],
    top_k=2,
    include_metadata=True,
    include_vectors=True,
    namespace="example-namespace",
)
with handle:
    # `results` contains the first batch
    for r in results:
        print(r.id, r.metadata, getattr(r, "vector", None))
    # fetch more results (fetch_next returns a list)
    more = handle.fetch_next(3)
    for r in more:
        print(r.id)
    # when the context block exits the handle is stopped automatically
```

--------------------------------

### Run the chatbot with npm run dev

Source: https://upstash.com/docs/vector/integrations/ai-sdk

Starts the chatbot development server. Run this command in the project directory after completing the setup.

```bash
npm run dev
```

--------------------------------

### 200 OK response for GET /info

Source: https://upstash.com/docs/vector/api/endpoints/info

Example response from the GET /info endpoint, showing index metadata such as vector counts, index size, dimension, similarity function, index type, and namespace details.

```json
{
  "result": {
    "vectorCount": 7,
    "pendingVectorCount": 0,
    "indexSize": 43501,
    "dimension": 1024,
    "similarityFunction": "COSINE",
    "indexType": "HYBRID",
    "denseIndex": {
      "dimension": 1536,
      "similarityFunction": "COSINE",
      "embeddingModel": "TEXT_EMBEDDING_3_SMALL"
    },
    "sparseIndex": {
      "embeddingModel": "BM25"
    },
    "namespaces": {
      "": {
        "vectorCount": 6,
        "pendingVectorCount": 0
      },
      "ns": {
        "vectorCount": 1,
        "pendingVectorCount": 0
      }
    }
  }
}
```

--------------------------------

### Start Flowise with npx

Source: https://upstash.com/docs/vector/integrations/flowise

Run this command to start the Flowise server locally.

```bash
npx flowise start
```

--------------------------------

### Install required packages (bun)

Source: https://upstash.com/docs/vector/integrations/ai-sdk

Installs the same packages using bun.

```bash
bun install @ai-sdk/openai ai zod @upstash/vector
```

--------------------------------

### Install the SDK with Composer

Source: https://upstash.com/docs/vector/sdks/php/getting-started

Use Composer to install the upstash/vector package.

```bash
composer require upstash/vector
```

--------------------------------

### Install required packages (npm)

Source: https://upstash.com/docs/vector/integrations/ai-sdk

Installs the AI SDK, OpenAI provider, Zod, and Upstash Vector client using npm.

```bash
npm install @ai-sdk/openai ai zod @upstash/vector
```

--------------------------------

### Install Bun

Source: https://upstash.com/docs/vector/sdks/ts/contributing

Installs the Bun runtime, which is required for packaging and dependency management in this project.

```bash
curl -fsSL https://bun.sh/install | bash
```

--------------------------------

### Install Required Libraries via PyPI

Source: https://upstash.com/docs/vector/tutorials/langchain

Install upstash-vector, python-dotenv, langchain, and langchain-community using pip.

```bash
pip install upstash-vector python-dotenv langchain langchain-community
```

--------------------------------

### Install required packages (pnpm)

Source: https://upstash.com/docs/vector/integrations/ai-sdk

Installs the same packages using pnpm.

```bash
pnpm install @ai-sdk/openai ai zod @upstash/vector
```

--------------------------------

### Get index statistics with index.info()

Source: https://upstash.com/docs/vector/sdks/py/example_calls/info

Use `Index.from_env()` to create an index client from environment variables, then call `index.info()` to retrieve statistical information. The example prints each field, including iterating over the `namespaces` dictionary to display per-namespace vector counts.

```python
from upstash_vector import Index
index = Index.from_env()
from upstash_vector import Index
index = Index.from_env()
# Get statistical information about the index
info_result = index.info()
# Display the info result
print("Vector Count:", info_result.vector_count)
print("Pending Vector Count:", info_result.pending_vector_count)
print("Index Size:", info_result.index_size)
print("Dimension:", info_result.dimension)
print("Similarity Function:", info_result.similarity_function)
for ns, ns_info in info_result.namespaces.items():
    print("Namespace:", ns, "Vector Count:", ns_info.vector_count)
    print("Namespace:", ns, "Pending Vector Count:", ns_info.pending_vector_count)
```

--------------------------------

### Example Output for Query 'What is Python?'

Source: https://upstash.com/docs/vector/tutorials/semantic_search

Example output showing the insertion of five documents and the search results for the query 'What is Python?'. Results include document IDs, scores, and metadata, with the most relevant document (ID 1) having the highest score.

```plaintext
Document 1 inserted.
Document 2 inserted.
Document 3 inserted.
Document 4 inserted.
Document 5 inserted.
Search Results:
ID: 1
Score: 0.9080
Metadata: {'text': 'Python is a popular programming language.'}
----------------------------------------
ID: 2
Score: 0.7592
Metadata: {'text': 'Machine learning enables computers to learn from data.'}
----------------------------------------
ID: 4
Score: 0.7388
Metadata: {'text': 'Semantic search is a technique for understanding the meaning of queries.'}
----------------------------------------
```

--------------------------------

### Install @upstash/vector with npm

Source: https://upstash.com/docs/vector/sdks/ts/getting-started

Install the @upstash/vector package using npm.

```bash
npm install @upstash/vector
```

--------------------------------

### Query Example

Source: https://upstash.com/docs/vector/sdks/py/example_calls/query

Python example using `index.query` to retrieve top-k similar vectors with metadata, data, and optional vectors. The example uses a random query vector, a filter for genre and title, and prints the results.

```python
import random
from upstash_vector import Index

index = Index.from_env()

# Generate a random vector for similarity comparison
dimension = 128  # Adjust based on your index's dimension
query_vector = [random.random() for _ in range(dimension)]

# Execute the query
query_result = index.query(
    vector=query_vector,
    include_metadata=True,
    include_data=True,
    include_vectors=False,
    top_k=5,
    filter="genre = 'fantasy' and title = 'Lord of the Rings'",
)

# Print the query result
for result in query_result:
    print("Score:", result.score)
    print("ID:", result.id)
    print("Vector:", result.vector)
    print("Metadata:", result.metadata)
    print("Data:", result.data)
```

--------------------------------

### Install upstash/vector-laravel with Composer

Source: https://upstash.com/docs/vector/sdks/php/laravel

Run this command to install the Laravel SDK for Upstash Vector.

```bash
composer require upstash/vector-laravel
```

--------------------------------

### Install @upstash/vector with pnpm

Source: https://upstash.com/docs/vector/sdks/ts/getting-started

Install the @upstash/vector package using pnpm.

```bash
pnpm add @upstash/vector
```

--------------------------------

### Install LlamaIndex and Upstash Vector packages

Source: https://upstash.com/docs/vector/integrations/llamaindex

Install the required Python packages for LlamaIndex, Upstash Vector, and environment variable loading.

```bash
pip install llama-index upstash-vector llama-index-vector-stores-upstash python-dotenv
```

--------------------------------

### Response for starting a resumable query

Source: https://upstash.com/docs/vector/api/endpoints/resumable-query/start-with-vector

Example 200 OK response containing a UUID for the resumable query and an initial batch of scores. The scores include vector IDs, similarity scores, and optional metadata.

```json
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000",
  "scores": [
    {
      "id": "id-0",
      "score": 1.0,
      "metadata": {
        "link": "upstash.com"
      }
    },
    {
      "id": "id-1",
      "score": 0.99996454
    }
  ]
}
```

--------------------------------

### Batch Query Example

Source: https://upstash.com/docs/vector/sdks/py/example_calls/query

Python example using `index.query_many` to perform multiple queries in a single call, reducing round trips. The example sends two queries with different parameters and prints the results for each.

```python
import random
from upstash_vector import Index

index = Index.from_env()

# Generate a random vector for similarity comparison
dimension = 128  # Adjust based on your index's dimension
query_vectors = [[random.random() for _ in range(dimension)] for _ in range(2)]

# Execute the query
query_results = index.query_many(
    queries=[
        {
            "vector": query_vectors[0],
            "include_metadata": True,
            "include_data": True,
            "include_vectors": False,
            "top_k": 5,
            "filter": "genre = 'fantasy' and title = 'Lord of the Rings'",
        },
        {
            "vector": query_vectors[1],
            "include_metadata": False,
            "include_data": False,
            "include_vectors": True,
            "top_k": 3,
            "filter": "genre = 'drama'",
        },
    ]
)

for i, query_result in enumerate(query_results):
    print(f"Query-{i} result:")
    # Print the query result
    for result in query_result:
        print("Score:", result.score)
        print("ID:", result.id)
        print("Vector:", result.vector)
        print("Metadata:", result.metadata)
        print("Data:", result.data)
```

--------------------------------

### Install Flowise globally with npm

Source: https://upstash.com/docs/vector/integrations/flowise

Run this command to install Flowise globally on your system using npm.

```bash
npm install -g flowise
```

--------------------------------

### Start resumable query with curl (namespace 'ns')

Source: https://upstash.com/docs/vector/api/endpoints/resumable-query/start-with-vector

Sends a POST request to the resumable-query endpoint with the namespace 'ns', using the UPSTASH_VECTOR_REST_URL and UPSTASH_VECTOR_REST_TOKEN environment variables. The request body is identical to the default namespace example.

```bash
curl $UPSTASH_VECTOR_REST_URL/resumable-query/ns \
  -X POST \
  -H "Authorization: Bearer $UPSTASH_VECTOR_REST_TOKEN" \
  -d '{
    "vector": [0.1, 0.2],
    "topK": 2,
    "includeMetadata": true,
    "maxIdle": 3600
  }'
```

--------------------------------

### Start resumable query with max idle time (Go)

Source: https://upstash.com/docs/vector/features/resumablequery

Starts a resumable query with a custom max idle time in seconds. The default is 1 hour; setting MaxIdle to 7200 allows the query to remain active for two hours before being automatically stopped.

```go
scores, handle, err := index.ResumableQuery(vector.ResumableQuery{
	Vector:          []float32{0.1, 0.2},
	TopK:            2,
	IncludeMetadata: true,
	MaxIdle:         7200, // two hours, in seconds
})
```

--------------------------------

### Install Upstash Vector and LangChain dependencies

Source: https://upstash.com/docs/vector/integrations/langchain

Install the required packages for using Upstash Vector with LangChain.

```bash
pip install upstash-vector langchain langchain-community python-dotenv
```

--------------------------------

### Install upstash-vector via pip

Source: https://upstash.com/docs/vector/sdks/py/gettingstarted

Install the upstash-vector package from PyPI using pip.

```bash
pip install upstash-vector
```

--------------------------------

### Sparse / hybrid example (showing advanced options)

Source: https://upstash.com/docs/vector/sdks/py/example_calls/resumable-query

Uses sparse vectors and hybrid scoring options. Demonstrates fetching initial results and additional results with the handle.

```python
from upstash_vector.types import SparseVector, WeightingStrategy, FusionAlgorithm
scores, handle = index.resumable_query(
    vector=[0.1, 0.1],
    sparse_vector=([0], [0.1]),
    top_k=2,
    include_vectors=True,
    include_metadata=True,
    include_data=True,
    weighting_strategy=WeightingStrategy.IDF,
    fusion_algorithm=FusionAlgorithm.DBSF,
    namespace="hybrid-ns",
)
with handle:
    for s in scores:
        print(s.id, getattr(s, "vector", None), getattr(s, "sparse_vector", None))
    more = handle.fetch_next(1)
    print("more:", more)
```

--------------------------------

### Start a resumable query with Python SDK

Source: https://upstash.com/docs/vector/features/resumablequery

Use Index.resumable_query to start a resumable query. The response includes the first batch of results and a handle for continuing the query. Filters and flags like include_metadata apply to the entire resumable query.

```python
from upstash_vector import Index

index = Index(
    url="UPSTASH_VECTOR_REST_URL",
    token="UPSTASH_VECTOR_REST_TOKEN",
)

result, handle = index.resumable_query(
    vector=[0.1, 0.2],
    top_k=2,
    include_metadata=True,
)

# first batch of the results
for r in result:
    print(r)
```

--------------------------------

### Install Langflow and Upstash Vector

Source: https://upstash.com/docs/vector/integrations/langflow

Run this command to install Langflow and the Upstash Vector Python package locally.

```bash
pip install langflow upstash-vector
```

--------------------------------

### Use the Vector facade to fetch index info

Source: https://upstash.com/docs/vector/sdks/php/laravel

After setting environment variables, call the Vector facade to access the index. This example fetches index info.

```php
use Upstash\Vector\Laravel\Facades\Vector;

Vector::getInfo(); // Fetches the index info.
```

--------------------------------

### Query with Namespace

Source: https://upstash.com/docs/vector/sdks/py/example_calls/query

Python example showing how to specify a namespace in a query. When no namespace is provided, the default namespace is used.

```python
index.query(..., namespace="ns")
```

--------------------------------

### Go: Query with DBSF fusion

Source: https://upstash.com/docs/vector/features/hybridindexes

Go example using the upstash/vector-go library to query with a dense vector, a sparse vector, and the DBSF fusion algorithm. Requires UPSTASH_VECTOR_REST_URL and UPSTASH_VECTOR_REST_TOKEN.

```go
package mainimport (    "github.com/upstash/vector-go")func main() {    index := vector.NewIndex(        "UPSTASH_VECTOR_REST_URL",        "UPSTASH_VECTOR_REST_TOKEN",    )    scores, err := index.Query(vector.Query{        Vector: []float32{0.5, 0.4},        SparseVector: &vector.SparseVector{            Indices: []int32{3, 5},            Values:  []float32{0.3, 05},        },        FusionAlgorithm: vector.FusionAlgorithmDBSF,    })}
```

--------------------------------

### Update response example

Source: https://upstash.com/docs/vector/api/endpoints/update

Example response from the update endpoint. The 'updated' field is 1 if any vector was updated, 0 otherwise.

```json
{
    "result": {
        "updated": 1
    }
}
```

--------------------------------

### Fetch API response example

Source: https://upstash.com/docs/vector/api/endpoints/fetch

Example 200 OK response for a fetch request. Shows the result array with vector objects, including metadata for id-0 and no metadata for id-1.

```json
{
    "result": [
        {
            "id": "id-0",
            "metadata": {
                "link": "upstash.com"
            }
        },
        {
            "id": "id-1"
        }
    ]
}
```

--------------------------------

### Sample Output from Queries

Source: https://upstash.com/docs/vector/tutorials/llamaindex

Example output from the queries, showing the generated responses about global warming and dietary changes.

```plaintext
Global warming refers to the long-term increase in Earth’s average temperature due to the accumulation of greenhouse gases (GHGs) such as carbon dioxide (CO2), methane (CH4), and nitrous oxide (N2O) in the atmosphere. The primary drivers of GHG emissions include the burning of fossil fuels for energy, industrial processes, deforestation, and unsustainable agricultural practices. As these gases trap heat, they create a “greenhouse effect,” leading to rising temperatures, melting polar ice caps, rising sea...
Shifting towards plant-based diets, which emphasize the consumption of vegetables, fruits, legumes, grains, and nuts, can significantly reduce our carbon footprint. Plant-based diets have a much lower environmental footprint compared to animal-based foods, particularly red meat, which is highly resource-intensive and contributes disproportionately to greenhouse gas emissions. Studies have shown that reducing the consumption of animal-based foods and increasing the intake of plant-based foods can help red...
```

--------------------------------

### Start a resumable query with JavaScript SDK

Source: https://upstash.com/docs/vector/features/resumablequery

Use Index.resumableQuery to start a resumable query. The response includes the first batch of results and a fetchNext function for continuing the query. Filters and flags like includeMetadata apply to the entire resumable query.

```javascript
import { Index } from "@upstash/vector"

const index = new Index({
  url: "UPSTASH_VECTOR_REST_URL",
  token: "UPSTASH_VECTOR_REST_TOKEN",
});

const { result, fetchNext, stop } = await index.resumableQuery({
  vector: [0.1, 0.2],
  topK: 2,
  includeMetadata: true,
});

// first batch of the results
for (let r of result) {
  console.log(r);
}
```

--------------------------------

### Install dependencies

Source: https://upstash.com/docs/vector/tutorials/gradio-application

Install required Python packages for the Gradio app, including gradio, langchain, sentence_transformers, upstash-vector, python-dotenv, transformers, and langchain-community.

```bash
pip install gradio langchain sentence_transformers upstash-vector python-dotenv transformers langchain-community langchain-huggingface
```

--------------------------------

### Start a resumable query with Go SDK

Source: https://upstash.com/docs/vector/features/resumablequery

Use vector.Index.ResumableQuery to start a resumable query. The response includes the first batch of scores and a handle for continuing the query. Filters and flags like IncludeMetadata apply to the entire resumable query. The handle must be closed with defer handle.Close().

```go
package main

import (
	"fmt"
	"log"
	"github.com/upstash/vector-go"
)

func main() {
	index := vector.NewIndex(
		"UPSTASH_VECTOR_REST_URL",
		"UPSTASH_VECTOR_REST_TOKEN",
	)

	scores, handle, err := index.ResumableQuery(vector.ResumableQuery{
		Vector:          []float32{0.1, 0.2},
		TopK:            2,
		IncludeMetadata: true,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close()

	// first batch of the results
	for _, score := range scores {
		fmt.Printf("%+v\n", score)
	}
}
```

--------------------------------

### index.ResumableQuery (Go)

Source: https://upstash.com/docs/vector/features/resumablequery

Starts a resumable query using the Go SDK. Returns scores, a handle, and an error.

```APIDOC
## index.ResumableQuery (Go)

### Description
Starts a resumable query using the Go SDK. Returns scores, a handle, and an error.

### Method
ResumableQuery

### Parameters
- **Vector** ([]float32) - Required - The query vector.
- **TopK** (integer) - Required - The maximum number of results to return.
- **IncludeMetadata** (boolean) - Optional - Whether to include metadata in the results.

### Request Example
```go
package main

import (
	"fmt"
	"log"
	"github.com/upstash/vector-go"
)

func main() {
	index := vector.NewIndex(
		"UPSTASH_VECTOR_REST_URL",
		"UPSTASH_VECTOR_REST_TOKEN",
	)
	scores, handle, err := index.ResumableQuery(vector.ResumableQuery{
		Vector:          []float32{0.1, 0.2},
		TopK:            2,
		IncludeMetadata: true,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close()
}
```

### Response
Returns `scores` (first batch of results), `handle` (to continue the query), and `err` (error if any).
```

--------------------------------

### 200 OK response for list-namespaces

Source: https://upstash.com/docs/vector/api/endpoints/list-namespaces

Example response showing the result array containing namespace names, including the default namespace as an empty string.

```json
{
    "result": ["", "ns0", "ns1"]
}
```

--------------------------------

### Query with RRF (Go)

Source: https://upstash.com/docs/vector/features/hybridindexes

Go SDK example for querying a hybrid index with the RRF fusion algorithm explicitly set.

```APIDOC
## Query with RRF (Go)

### Description
Performs a hybrid query using the RRF fusion algorithm in the Upstash Vector Go SDK.

### Method
Query

### Endpoint
Index.Query()

### Parameters
- **Vector** ([]float32) - Required - The dense vector for the query.
- **SparseVector** (*SparseVector) - Required - The sparse vector with `Indices` and `Values`.
- **FusionAlgorithm** (FusionAlgorithm) - Required - Set to vector.FusionAlgorithmRRF to use Reciprocal Rank Fusion.

### Request Example
```go
package main

import (
	"github.com/upstash/vector-go"
)

func main() {
	index := vector.NewIndex(
		"UPSTASH_VECTOR_REST_URL",
		"UPSTASH_VECTOR_REST_TOKEN",
	)

	scores, err := index.Query(vector.Query{
		Vector: []float32{0.5, 0.4},
		SparseVector: &vector.SparseVector{
			Indices: []int32{3, 5},
			Values:  []float32{0.3, 05},
		},
		FusionAlgorithm: vector.FusionAlgorithmRRF,
	})
}
```

### Response
Returns the query results with combined scores from dense and sparse indexes using RRF.
```

--------------------------------

### Start resumable query with max idle time (Python)

Source: https://upstash.com/docs/vector/features/resumablequery

Starts a resumable query with a custom max idle time in seconds. The default is 1 hour; setting max_idle to 7200 allows the query to remain active for two hours before being automatically stopped.

```python
result, handle = index.resumable_query(
    vector=[0.1, 0.2],
    top_k=2,
    include_metadata=True,
    max_idle = 7200, # two hours, in seconds
)
```

--------------------------------

### Install upstash-vector and python-dotenv

Source: https://upstash.com/docs/vector/tutorials/semantic_search

Install the required Python libraries using pip. The upstash-vector library is used for interacting with Upstash Vector, and python-dotenv loads environment variables from the .env file.

```bash
pip install upstash-vector python-dotenv
```

--------------------------------

### Start resumable query with max idle time (JavaScript)

Source: https://upstash.com/docs/vector/features/resumablequery

Starts a resumable query with a custom max idle time in seconds. The default is 1 hour; setting maxIdle to 7200 allows the query to remain active for two hours before being automatically stopped.

```javascript
const { result, fetchNext, stop } = await index.resumableQuery({
  vector: [0.1, 0.2],
  topK: 2,
  includeMetadata: true,
  maxIdle: 7200, // two hours, in seconds
});
```

--------------------------------

### Start resumable query with max idle time (cURL)

Source: https://upstash.com/docs/vector/features/resumablequery

Sends a POST request to the /resumable-query endpoint with the vector, topK, includeMetadata, and maxIdle parameters to start a resumable query with a custom idle timeout.

```curl
curl $UPSTASH_VECTOR_REST_URL/resumable-query \
  -X POST \
  -H "Authorization: Bearer $UPSTASH_VECTOR_REST_TOKEN" \
  -d '{
    "vector": [0.1, 0.2],
    "topK": 2,
    "includeMetadata": true,
    "maxIdle": 7200
  }'
```

--------------------------------

### index.resumable_query (Python)

Source: https://upstash.com/docs/vector/features/resumablequery

Starts a resumable query using the Python SDK. Returns a tuple of results and a handle.

```APIDOC
## index.resumable_query (Python)

### Description
Starts a resumable query using the Python SDK. Returns a tuple of results and a handle.

### Method
resumable_query

### Parameters
- **vector** (list of float) - Required - The query vector.
- **top_k** (integer) - Required - The maximum number of results to return.
- **include_metadata** (boolean) - Optional - Whether to include metadata in the results.

### Request Example
```python
from upstash_vector import Index

index = Index(
    url="UPSTASH_VECTOR_REST_URL",
    token="UPSTASH_VECTOR_REST_TOKEN",
)
result, handle = index.resumable_query(
    vector=[0.1, 0.2],
    top_k=2,
    include_metadata=True,
)
```

### Response
Returns a tuple `(result, handle)` where `result` is the first batch of results and `handle` is used to continue the query.
```

--------------------------------

### Query response with metadata

Source: https://upstash.com/docs/vector/features/metadata

Example JSON response from a query that includes metadata for each result.

```json
{
  "result": [
    {
      "id": "id-0",
      "score": 1,
      "metadata": {
        "url": "https://imgur.com/z9AVZLb"
      }
    },
    {
      "id": "id-3",
      "score": 0.99961007,
      "metadata": {
        "url": "https://imgur.com/zfOPmnI"
      }
    }
  ]
}
```

--------------------------------

### Query with RRF (PHP)

Source: https://upstash.com/docs/vector/features/hybridindexes

PHP SDK example for querying a hybrid index with the RRF fusion algorithm explicitly set.

```APIDOC
## Query with RRF (PHP)

### Description
Performs a hybrid query using the RRF fusion algorithm in the Upstash Vector PHP SDK.

### Method
query

### Endpoint
Index->query()

### Parameters
- **vector** (array) - Required - The dense vector for the query.
- **sparseVector** (SparseVector) - Required - The sparse vector with `indices` and `values`.
- **topK** (int) - Optional - The number of top results to return.
- **includeMetadata** (bool) - Optional - Whether to include metadata in the results.
- **fusionAlgorithm** (FusionAlgorithm) - Required - Set to FusionAlgorithm::RECIPROCAL_RANK_FUSION to use RRF.

### Request Example
```php
use Upstash\Vector\Index;
use Upstash\Vector\VectorQuery;
use Upstash\Vector\SparseVector;
use Upstash\Vector\Enums\FusionAlgorithm;

$index = new Index(
  url: 'UPSTASH_VECTOR_REST_URL',
  token: 'UPSTASH_VECTOR_REST_TOKEN',
);

$index->query(new VectorQuery(
  vector: [0.5, 0.4],
  sparseVector: new SparseVector(
    indices: [3, 5],
    values: [0.3, 0.5],
  ),
  topK: 5,
  includeMetadata: true,
  fusionAlgorithm: FusionAlgorithm::RECIPROCAL_RANK_FUSION,
));
```

### Response
Returns the query results with combined scores from dense and sparse indexes using RRF.
```

--------------------------------

### Initialize the client from environment variables

Source: https://upstash.com/docs/vector/sdks/php/getting-started

Create an Index instance using the UPSTASH_VECTOR_REST_URL and UPSTASH_VECTOR_REST_TOKEN environment variables.

```php
use Upstash\Vector\Index;

$index = Index::fromEnv();
```

--------------------------------

### Go - Query with DBSF

Source: https://upstash.com/docs/vector/features/hybridindexes

Example of using the Upstash Vector Go SDK to perform a hybrid query with DBSF fusion algorithm.

```APIDOC
## Go - Query with DBSF

### Description
Performs a hybrid query using the DBSF fusion algorithm to combine dense and sparse vector results.

### Method
Query

### Endpoint
index.Query()

### Parameters
- **Vector** ([]float32) - Required - The dense vector for the query.
- **SparseVector** (*vector.SparseVector) - Required - The sparse vector with `Indices` and `Values` fields.
- **FusionAlgorithm** (vector.FusionAlgorithm) - Required - Set to vector.FusionAlgorithmDBSF.

### Request Example
```go
package main

import (
	"github.com/upstash/vector-go"
)

func main() {
	index := vector.NewIndex(
		"UPSTASH_VECTOR_REST_URL",
		"UPSTASH_VECTOR_REST_TOKEN",
	)

	scores, err := index.Query(vector.Query{
		Vector: []float32{0.5, 0.4},
		SparseVector: &vector.SparseVector{
			Indices: []int32{3, 5},
			Values:  []float32{0.3, 05},
		},
		FusionAlgorithm: vector.FusionAlgorithmDBSF,
	})
}
```

### Response
Returns the top-K results sorted by combined normalized scores.
```

--------------------------------

### Manually initialize the client with URL and token

Source: https://upstash.com/docs/vector/sdks/php/getting-started

Instantiate the Index by passing the REST URL and token directly to the constructor, useful for multiple project configurations.

```php
use Upstash\Vector\Index;

$index = new Index(
  url: "<UPSTASH_VECTOR_REST_URL>",
  token: "<UPSTASH_VECTOR_REST_TOKEN>",
);
```

--------------------------------

### Python: Query with DBSF fusion

Source: https://upstash.com/docs/vector/features/hybridindexes

Python example using the upstash_vector Index to query with a dense vector, a sparse vector, and the DBSF fusion algorithm. Requires UPSTASH_VECTOR_REST_URL and UPSTASH_VECTOR_REST_TOKEN.

```python
from upstash_vector import Indexfrom upstash_vector.types import FusionAlgorithm, SparseVectorindex = Index(    url="UPSTASH_VECTOR_REST_URL",    token="UPSTASH_VECTOR_REST_TOKEN",)index.query(    vector=[0.5, 0.4],    sparse_vector=SparseVector([3, 5], [0.3, 0.5]),    fusion_algorithm=FusionAlgorithm.DBSF,)
```

--------------------------------

### POST /resumable-query

Source: https://upstash.com/docs/vector/features/resumablequery

Starts a resumable query. Returns the first batch of results and a handle to continue the query.

```APIDOC
## POST /resumable-query

### Description
Starts a resumable query. Returns the first batch of results and a handle to continue the query.

### Method
POST

### Endpoint
/resumable-query

### Parameters
#### Request Body
- **vector** (array of numbers) - Required - The query vector.
- **topK** (integer) - Required - The maximum number of results to return.
- **includeMetadata** (boolean) - Optional - Whether to include metadata in the results.

### Request Example
```json
{
  "vector": [0.1, 0.2],
  "topK": 2,
  "includeMetadata": true
}
```

### Response
#### Success Response (200)
- **result** (array) - The first batch of most similar vectors.
- **handle** (string) - A handle to continue the query.

#### Response Example
```json
{
  "result": [
    {
      "id": "vector-id-1",
      "score": 0.95,
      "metadata": {"key": "value"}
    }
  ],
  "handle": "unique-handle"
}
```
```

--------------------------------

### Query with RRF (Python)

Source: https://upstash.com/docs/vector/features/hybridindexes

Python SDK example for querying a hybrid index with the RRF fusion algorithm explicitly set.

```APIDOC
## Query with RRF (Python)

### Description
Performs a hybrid query using the RRF fusion algorithm in the Upstash Vector Python SDK.

### Method
query

### Endpoint
Index.query()

### Parameters
- **vector** (list[float]) - Required - The dense vector for the query.
- **sparse_vector** (SparseVector) - Required - The sparse vector for the query.
- **fusion_algorithm** (FusionAlgorithm) - Required - Set to FusionAlgorithm.RRF to use Reciprocal Rank Fusion.

### Request Example
```python
from upstash_vector import Index
from upstash_vector.types import FusionAlgorithm, SparseVector

index = Index(
    url="UPSTASH_VECTOR_REST_URL",
    token="UPSTASH_VECTOR_REST_TOKEN",
)

index.query(
    vector=[0.5, 0.4],
    sparse_vector=SparseVector([3, 5], [0.3, 0.5]),
    fusion_algorithm=FusionAlgorithm.RRF,
)
```

### Response
Returns the query results with combined scores from dense and sparse indexes using RRF.
```

--------------------------------

### PHP: Query with DBSF fusion

Source: https://upstash.com/docs/vector/features/hybridindexes

PHP example using the Upstash\Vector\Index class to query with a dense vector, a sparse vector, and the DBSF fusion algorithm. Requires UPSTASH_VECTOR_REST_URL and UPSTASH_VECTOR_REST_TOKEN.

```php
use Upstash\Vector\Index;use Upstash\Vector\VectorQuery;use Upstash\Vector\SparseVector;use Upstash\Vector\Enums\FusionAlgorithm;$index = new Index(  url: 'UPSTASH_VECTOR_REST_URL',  token: 'UPSTASH_VECTOR_REST_TOKEN',);$index->query(new VectorQuery(  vector: [0.5, 0.4],  sparseVector: new SparseVector(    indices: [3, 5],    values: [0.3, 0.5],  ),  topK: 5,  includeMetadata: true,  fusionAlgorithm: FusionAlgorithm::DISTRIBUTION_BASED_SCORE_FUSION,));
```

--------------------------------

### Fetch vectors by ID prefix in a custom namespace

Source: https://upstash.com/docs/vector/sdks/php/commands/fetch

Same as the default namespace example but uses the namespace('my-namespace') method to fetch vectors by prefix from a specific namespace.

```php
use Upstash\Vector\Index;
use Upstash\Vector\VectorFetchByPrefix;

$index = new Index(
  url: "<UPSTASH_VECTOR_REST_URL>",
  token: "<UPSTASH_VECTOR_REST_TOKEN>",
);

$results = $index->namespace('my-namespace')->fetch(new VectorFetchByPrefix(
  prefix: 'users:',
  includeMetadata: true, // (optional) if true the fetch results will contain metadata.
  includeVectors: true, // (optional) if true the fetch results will contain the indexed vectors.
  includeData: true, // (optional) if true the fetch results will contain the string data.
));
```

--------------------------------

### Query parsed document with Upstash Vector and OpenAI

Source: https://upstash.com/docs/vector/tutorials/llamaparse

Set up UpstashVectorStore, create an index from parsed documents, and query it using an LLM. The example uses OpenAI as the language model.

```python
from llama_index.core import VectorStoreIndex
from llama_index.vector_stores.upstash import UpstashVectorStore
from llama_index.core import StorageContext
import openai

# Load environment variables for API keys and Upstash configuration
from dotenv import load_dotenv
import os
load_dotenv()

# Set up OpenAI API key
openai.api_key = os.getenv("OPENAI_API_KEY")

# Set up Upstash Vector Store
upstash_vector_store = UpstashVectorStore(
    url=os.getenv("UPSTASH_VECTOR_REST_URL"),
    token=os.getenv("UPSTASH_VECTOR_REST_TOKEN"),
)

# Create a storage context for Upstash Vector and index the parsed document
storage_context = StorageContext.from_defaults(vector_store=upstash_vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

# Create a query engine for the index and perform a query
query_engine = index.as_query_engine()
query = "What are the main points discussed in the document?"
response = query_engine.query(query)
print(response)
```

--------------------------------

### Query with RRF (JavaScript)

Source: https://upstash.com/docs/vector/features/hybridindexes

JavaScript SDK example for querying a hybrid index with the RRF fusion algorithm explicitly set.

```APIDOC
## Query with RRF (JavaScript)

### Description
Performs a hybrid query using the RRF fusion algorithm in the Upstash Vector JavaScript SDK.

### Method
query

### Endpoint
Index.query()

### Parameters
- **vector** (number[]) - Required - The dense vector for the query.
- **sparseVector** (object) - Required - The sparse vector with `indices` and `values` arrays.
- **fusionAlgorithm** (FusionAlgorithm) - Required - Set to FusionAlgorithm.RRF to use Reciprocal Rank Fusion.
- **topK** (number) - Optional - The number of top results to return.

### Request Example
```javascript
import { FusionAlgorithm, Index } from "@upstash/vector";

const index = new Index({
  url: "UPSTASH_VECTOR_REST_URL",
  token: "UPSTASH_VECTOR_REST_TOKEN",
});

await index.query({
  vector: [0.5, 0.4],
  sparseVector: {
    indices: [2, 3],
    values: [0.13, 0.87],
  },
  fusionAlgorithm: FusionAlgorithm.RRF,
  topK: 3,
});
```

### Response
Returns the query results with combined scores from dense and sparse indexes using RRF.
```

--------------------------------

### Fetch vectors by ID in a custom namespace

Source: https://upstash.com/docs/vector/sdks/php/commands/fetch

Same as the default namespace example but uses the namespace('my-namespace') method to fetch vectors from a specific namespace.

```php
use Upstash\Vector\Index;
use Upstash\Vector\VectorFetch;

$index = new Index(
  url: "<UPSTASH_VECTOR_REST_URL>",
  token: "<UPSTASH_VECTOR_REST_TOKEN>",
);

$results = $index->namespace('my-namespace')->fetch(new VectorFetch(
  ids: ['1', '2'],
  includeMetadata: true, // (optional) if true the fetch results will contain metadata.
  includeVectors: true, // (optional) if true the fetch results will contain the indexed vectors.
  includeData: true, // (optional) if true the fetch results will contain the string data.
));
```

--------------------------------

### Example response for random vector

Source: https://upstash.com/docs/vector/api/endpoints/fetch-random

Shows a 200 OK response containing a random vector with an id and vector values.

```json
{
    "result": {
        "id": "id-0",
        "vector": [0.1, 0.2]
    }
}
```

--------------------------------

### Create .env file

Source: https://upstash.com/docs/vector/tutorials/gradio-application

Set up environment variables for Upstash Vector credentials. Replace placeholders with actual values.

```plaintext
UPSTASH_VECTOR_REST_URL=your_upstash_url
UPSTASH_VECTOR_REST_TOKEN=your_upstash_token
```

--------------------------------

### JavaScript: Query with DBSF fusion

Source: https://upstash.com/docs/vector/features/hybridindexes

JavaScript example using the @upstash/vector Index to query with a dense vector, a sparse vector, and the DBSF fusion algorithm. Requires UPSTASH_VECTOR_REST_URL and UPSTASH_VECTOR_REST_TOKEN.

```javascript
import { FusionAlgorithm, Index } from "@upstash/vector";const index = new Index({  url: "UPSTASH_VECTOR_REST_URL",  token: "UPSTASH_VECTOR_REST_TOKEN",});await index.query({  vector: [0.5, 0.4],  sparseVector: {    indices: [2, 3],    values: [0.13, 0.87],  },  fusionAlgorithm: FusionAlgorithm.DBSF,  topK: 3,});
```

--------------------------------

### PHP - Query with DBSF

Source: https://upstash.com/docs/vector/features/hybridindexes

Example of using the Upstash Vector PHP SDK to perform a hybrid query with DBSF fusion algorithm.

```APIDOC
## PHP - Query with DBSF

### Description
Performs a hybrid query using the DBSF fusion algorithm to combine dense and sparse vector results.

### Method
query

### Endpoint
$index->query()

### Parameters
- **vector** (array) - Required - The dense vector for the query.
- **sparseVector** (SparseVector) - Required - The sparse vector with `indices` and `values` arrays.
- **topK** (int) - Optional - The number of top results to return.
- **includeMetadata** (bool) - Optional - Whether to include metadata in the results.
- **fusionAlgorithm** (FusionAlgorithm) - Required - Set to FusionAlgorithm::DISTRIBUTION_BASED_SCORE_FUSION.

### Request Example
```php
use Upstash\Vector\Index;
use Upstash\Vector\VectorQuery;
use Upstash\Vector\SparseVector;
use Upstash\Vector\Enums\FusionAlgorithm;

$index = new Index(
  url: 'UPSTASH_VECTOR_REST_URL',
  token: 'UPSTASH_VECTOR_REST_TOKEN',
);

$index->query(new VectorQuery(
  vector: [0.5, 0.4],
  sparseVector: new SparseVector(
    indices: [3, 5],
    values: [0.3, 0.5],
  ),
  topK: 5,
  includeMetadata: true,
  fusionAlgorithm: FusionAlgorithm::DISTRIBUTION_BASED_SCORE_FUSION,
));
```

### Response
Returns the top-K results sorted by combined normalized scores.
```

--------------------------------

### Upsert and Query with Namespace

Source: https://upstash.com/docs/vector/features/namespaces

Namespaces are created implicitly when an upsert operation is performed. This example shows how to upsert and query vectors within a specific namespace.

```APIDOC
## Upsert and Query with Namespace

### Description
Namespaces are created implicitly when an upsert operation is performed. This example shows how to upsert and query vectors within a specific namespace.

### Method
POST

### Endpoint
`<vector-url>/upsert/namespace-name` and `<vector-url>/query/namespace-name`

### Parameters
#### Path Parameters
- `namespace-name` (string) - Required - The name of the namespace.

#### Request Body (Upsert)
- `id` (string) - Required - The vector ID.
- `vector` (array of numbers) - Required - The vector data.

#### Request Body (Query)
- `vector` (array of numbers) - Required - The query vector.
- `topK` (integer) - Required - The number of results to return.

### Request Example
```
curl $UPSTASH_VECTOR_REST_URL/upsert/ns \
  -X POST \
  -H "Authorization: Bearer $UPSTASH_VECTOR_REST_TOKEN" \
  -d '{"id":"id-0", "vector":[0.9215,0.3897]}'

curl $UPSTASH_VECTOR_REST_URL/query/ns \
  -H "Authorization: Bearer $UPSTASH_VECTOR_REST_TOKEN" \
  -d '{"vector":[0.9215,0.3897], "topK" : 5}'
```

### Response
#### Success Response (200)
- For upsert: Acknowledgment of the upsert operation.
- For query: A list of matching vectors.

#### Response Example
(Not provided in source)
```

--------------------------------

### Set up QA pipeline and Gradio interface

Source: https://upstash.com/docs/vector/tutorials/gradio-application

Configure a Hugging Face question-answering model and create a Gradio interface that retrieves relevant documents and provides answers.

```python
# Set up a Hugging Face Question Answering model
qa_pipeline = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")

# Gradio interface function
def answer_question(query):
    # Retrieve relevant documents from Upstash Vector
    results = vector_store.similarity_search(query, k=3)
    
    # Use the most relevant document for QA
    if results:
        context = results[0].page_content
        qa_input = {"question": query, "context": context}
        answer = qa_pipeline(qa_input)["answer"]
        return f"Answer: {answer}\n\nContext: {context}"
    else:
        return "No relevant context found."

# Set up Gradio interface
iface = gr.Interface(
    fn=answer_question,
    inputs="text",
    outputs="text",
    title="RAG Application",
    description="Ask a question, and the app will retrieve relevant information and provide an answer."
)

# Launch the Gradio app
iface.launch()
```

--------------------------------

### Initialize Upstash Vector Store and Create Index

Source: https://upstash.com/docs/vector/tutorials/llamaindex

Load environment variables, set up the UpstashVectorStore with your URL and token, read documents from the './documents/' directory, and create a VectorStoreIndex with the storage context. The index dimensions should be 1536 and distance metric Cosine as set in the Upstash Console.

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.vector_stores.upstash import UpstashVectorStore
from llama_index.core import StorageContext
import openai
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()
openai.api_key = os.environ["OPENAI_API_KEY"]

# Setup the Upstash vector store 
upstash_vector_store = UpstashVectorStore(
    url=os.environ["UPSTASH_VECTOR_REST_URL"],
    token=os.environ["UPSTASH_VECTOR_REST_TOKEN"],
)

# Read the document about global warming from the documents directory
documents = SimpleDirectoryReader("./documents/").load_data()

# Initialize the storage context with the Upstash vector store
storage_context = StorageContext.from_defaults(vector_store=upstash_vector_store)

# Create the index from the loaded document with 1536 dimensions and cosine distance
index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context
)
```

--------------------------------

### Basic range query example

Source: https://upstash.com/docs/vector/sdks/py/example_calls/range

Shows how to execute a range query using the `range` method on an `Index` instance created from environment variables. It retrieves up to 10 vectors, excludes vector data, includes metadata and data, and prints the results.

```python
from upstash_vector import Index
index = Index.from_env()
# Execute the range query
range_result = index.range(
    cursor="",
    limit=10,
    include_vectors=False,
    include_metadata=True,
    include_data=True,
)
# Print the range result
print("Next Cursor:", range_result.next_cursor)
for vector_info in range_result.vectors:
    print("ID:", vector_info.id)
    print("Vector:", vector_info.vector)
    print("Metadata:", vector_info.metadata)
    print("Data:", vector_info.data)
```

--------------------------------

### Initialize UpstashVectorStore with environment variables

Source: https://upstash.com/docs/vector/tutorials/langchain

Loads environment variables and creates an UpstashVectorStore instance with embeddings generated by Upstash. Requires the URL and token to be set in the environment.

```python
from dotenv import load_dotenvfrom langchain_community.vectorstores.upstash import UpstashVectorStoreload_dotenv()# Create a vector store instance where embeddings are generated by Upstashstore = UpstashVectorStore(embedding=True)
```

--------------------------------

### Initialize Index from environment variables

Source: https://upstash.com/docs/vector/sdks/py/gettingstarted

Initialize the Index client automatically using environment variables for credentials.

```python
from upstash_vector import Index
index = Index.from_env()
```
Tokens:
Raw