Support Pinecone-style two-line API for Upstash vector indexes

[Aayush1Singh]

Checked

• I searched existing ideas and did not find a similar one
• I added a very descriptive title
• I've clearly described the feature request and motivation for it

Feature request

Currently, LangChain requires manual setup of index to use Upstash Vector as compared to easy setup of indexes for Pinecone.This is more cumbersome than Pinecone’s API. I propose adding a first-class Upstash client class in LangChain (e.g. in langchain_community) with a simple two-line API. For example:

up = Upstash(email="[email protected]", api_token="UPSTASH_API_KEY")
index = up.Index("my-index")
vectorstore = UpstashVectorStore(
    embedding=embedding,
    index_url=os.getenv("UPSTASH_VECTOR_REST_URL"),
    index_token=os.getenv("UPSTASH_VECTOR_REST_TOKEN"),
    index=index,
    )

Motivation

Knowing the URL and token beforehand of a dynamically created Index is impossible without manual feeding/using REST API

I was working on a RAG based application and needed a vector database that stores embeddings with indexes, So while developing the application, I first used RedisVectorStore (on localhost) from langchain community as it worked very smooth.
When i went to deploy my application, i migrated to PineconeVectorStore and the migration was very smooth because the interface was nearly same as RedisVectorStore with a minor change of creation of a index object(specified in feature request), but due to Pinecone limitations of only providing for a limited indexes in its free tier, I decided to migrate to Upstash Redis.
Now here comes the problem, Though the interface for the PineCone and Upstash looks similar, Upstash requires the url and token of the index instead of index name(specified in below), and i needed to dynamically create indexes and retreive context, for which knowing url and token beforehand is impossible without manual feeding.
So i had to read through upstash documentation and make use REST API of upstash to first get the index's url and token and then to be able to create a Index object and use it similarly to Pinecone

Current Upstash Workflow vs Pinecone

Right now Upstash integration in LangChain requires three separate steps:

1. Manually call the Upstash REST API to create-or-fetch your index’s endpoint & token.

def create_index(index_name):
    data = {"name":index_name,"region":"us-east-1","similarity_function":"COSINE","dimension_count":768}
    data = json.dumps(data)
    data=str(data)
    print(data)
    response = requests.post('https://api.upstash.com/v2/vector/index', data=data, auth=(os.getenv('EMAIL'), os.getenv('UPSTASH_API')))
 
def get_index(index_name):
    print(index_name)
    response = requests.get(f"https://api.upstash.com/v2/vector/index/{index_name}",auth=(os.getenv('EMAIL'), os.getenv('UPSTASH_API')))
    op=response.json()
    return op['endpoint'],op['token']

2. Wrap those in an Index client: Index(url, token).

  url,token=get_index(index_name)
  index = Index(url=f"https://{url}", token=token)

3. Pass both your VectorStore REST creds and that Index client into UpstashVectorStore(...).

  vectorstore = UpstashVectorStore(
    embedding=embedding,
    index_url=os.getenv("UPSTASH_VECTOR_REST_URL"),
    index_token=os.getenv("UPSTASH_VECTOR_REST_TOKEN"),
    index=index,
    )

In contrast, Pinecone works like this:

1.Define a Pinecone object

  pc = Pinecone(api_key)

2.Pass the index name

  index = pc.Index("my-index") 

3.Declare the vectorStore

  vectorstore=PineconeVectorStore(index=index, embedding=embedding)

That extra boilerplate breaks the drop-in promise and clutters application code compared with Pinecone.

Why this matters

1. Dynamic deployments: You can spin up temporary indexes without console juggling.
2. Consistent DX: Switching providers becomes copy-paste, not a refactor.
3. Cleaner examples & docs: Tutorials can show one simple pattern for every store.

Proposal (If applicable)

I suggest implementing an Upstash client class that parallels Pinecone. Example usage:

up = Upstash(email="[email protected]", api_token="UPSTASH_API_KEY")
index = up.Index("my-index")
vectorstore = UpstashVectorStore(
embedding=embedding,
index_url=os.getenv("UPSTASH_VECTOR_REST_URL"),
index_token=os.getenv("UPSTASH_VECTOR_REST_TOKEN"),
index=index,
)

Internally, this client would automate the index setup:

1. Index retrieval/creation: On calling up.Index("name"), it would list existing indices via the Upstash REST API (GET /v2/vector/index) and, if not found, create it with POST /v2/vector/index.
2. Index instantiation: From the API response it would extract the endpoint (REST URL) and token and use them to initialize an upstash_vector.Index object (for example, via the Upstash Python SDK).