Run Semantic Search and RAG with Pinecone in Jinba Flow

Use PINECONE_CREATE_INDEX, PINECONE_UPSERT, and PINECONE_QUERY to build and query a vector index, with OPENAI_INVOKE to generate answers from query matches (RAG).

Pinecone is a fully managed vector database that enables semantic search and RAG (Retrieval-Augmented Generation) applications. The Pinecone tool allows you to query vector indexes for similar vectors using semantic similarity.

• PINECONE_CREATE_INDEX

  • Create new serverless vector indexes
  • Configure vector dimension and distance metric
  • Select cloud provider and deployment region
  • Optional integrated inference: set an embedding model and Pinecone embeds your text
  • Wait-until-ready option for immediate use

• PINECONE_QUERY

  • Search for similar vectors using semantic similarity
  • Dual-mode operation: Vector query OR text query with integrated inference
  • Support for top-K results retrieval
  • Metadata filtering with Pinecone filter syntax
  • Namespace isolation for data partitioning
  • Similarity threshold filtering (minScore)
  • Optional inclusion of metadata and vector values

• PINECONE_UPSERT

  • Insert or update vectors in Pinecone index
  • Dual-mode operation: Vector upsert OR document upsert with integrated inference
  • Batch operations (up to 100 vectors/documents per request)
  • Metadata support for rich vector annotations
  • Namespace isolation for data organization

Connect with Pinecone credentials

You need a Pinecone API key to use this tool. You can obtain one from the Pinecone Console.

Note: Treat API keys as sensitive information and never commit them to public repositories.

Create an index and upsert documents

Setting embeddingModel creates an index with integrated inference, so Pinecone embeds the text of each document and query for you. No dimension is needed; the model sets it.

# Step 1: Create a serverless index
- id: create_index
  name: create_index
  tool: PINECONE_CREATE_INDEX
  config:
    - name: apiKey
      value: "{{secrets.PINECONE_API_KEY}}"
  input:
    - name: indexName
      value: knowledge-base
    - name: embeddingModel
      value: multilingual-e5-large
    - name: cloud
      value: aws
    - name: region
      value: us-east-1
    - name: waitUntilReady
      value: true

# Step 2: Upload documents with automatic embedding
- id: upload_docs
  name: upload_docs
  tool: PINECONE_UPSERT
  needs: [create_index]
  config:
    - name: apiKey
      value: "{{secrets.PINECONE_API_KEY}}"
  input:
    - name: indexName
      value: knowledge-base
    - name: documents
      value: |
        [
          {
            "id": "doc1",
            "text": "Pinecone is a vector database optimized for AI applications.",
            "metadata": {"category": "intro", "source": "docs"}
          },
          {
            "id": "doc2",
            "text": "Integrated inference automatically generates embeddings from your text.",
            "metadata": {"category": "features", "source": "docs"}
          }
        ]

# Step 3: Query with text (automatic embedding)
- id: search
  name: search
  tool: PINECONE_QUERY
  needs: [upload_docs]
  config:
    - name: apiKey
      value: "{{secrets.PINECONE_API_KEY}}"
  input:
    - name: indexName
      value: knowledge-base
    - name: query
      value: "How does Pinecone handle embeddings?"
    - name: topK
      value: 3
    - name: includeMetadata
      value: true

The upsert returns the number of records written at steps.upload_docs.result.upsertedCount. The search results are at steps.search.result.matches; each match has id, score and metadata (the record’s stored fields, such as text and category).

Query an index

Example: Query with Reranking for Improved Relevance

Reranking re-scores initial results to improve relevance. This is especially useful for complex queries.

- id: search_with_rerank
  name: search_with_rerank
  tool: PINECONE_QUERY
  config:
    - name: apiKey
      value: "{{secrets.PINECONE_API_KEY}}"
  input:
    - name: indexName
      value: knowledge-base
    - name: query
      value: "How does Pinecone handle embeddings?"
    - name: topK
      value: 10
    - name: includeMetadata
      value: true
    - name: rerankModel
      value: bge-reranker-v2-m3  # Options: cohere-rerank-3.5, bge-reranker-v2-m3, pinecone-rerank-v0
    - name: rerankTopN
      value: 3
    - name: rerankRankFields
      value: '["text"]'
    - name: fields
      value: '["category", "text"]'

Reranking works with text queries (query). rerankRankFields is required when rerankModel is set, and every field in it must also be listed in fields. rerankTopN must not exceed topK.

Example: Search with Metadata Filtering

- id: filtered_search
  name: filtered_search
  tool: PINECONE_QUERY
  config:
    - name: apiKey
      value: "{{secrets.PINECONE_API_KEY}}"
  input:
    - name: indexName
      value: my-docs-index
    - name: query
      value: "How does Pinecone handle embeddings?"
    - name: topK
      value: 10
    - name: filter
      value: '{"category": {"$eq": "technology"}, "year": {"$gte": 2020}}'
    - name: namespace
      value: production

query only works on an index created with integrated inference. For an index without it, pass vector instead: a JSON array of numbers from the same embedding model the index was built with, with a length that matches the index dimension. Jinba Flow has no built-in embedding step, so a vector must come from an external source.

Example: Answer a Question with Retrieved Context (RAG)

Search the index with the user’s question, then pass the matches to an LLM as context.

- id: search
  name: search
  tool: PINECONE_QUERY
  config:
    - name: apiKey
      value: "{{secrets.PINECONE_API_KEY}}"
  input:
    - name: indexName
      value: knowledge-base
    - name: query
      value: "What is integrated inference?"
    - name: topK
      value: 5
    - name: minScore
      value: 0.5

- id: generate_answer
  name: generate_answer
  tool: OPENAI_INVOKE
  needs: [search]
  input:
    - name: prompt
      value: |
        Answer the question using only the context below.

        Context (JSON):
        {{steps.search.result.matches}}

        Question: What is integrated inference?

{{steps.search.result.matches}} is inserted as JSON text, so the LLM sees each match’s metadata.text. The answer is at steps.generate_answer.result.content.

Parameters

PINECONE_CREATE_INDEX

Parameter	Type	Required	Default	Description
indexName	string	Yes	-	Name of the index (lowercase alphanumeric and hyphens, max 45 chars)
dimension	number	No*	-	Vector dimension (e.g., 1536 for OpenAI ada-002). Required for a standard index
metric	string	No	cosine	Distance metric: cosine, euclidean, or dotproduct. Standard index only
cloud	string	No	aws	Cloud provider: aws, gcp, or azure
region	string	Yes	-	Deployment region (e.g., us-east-1)
waitUntilReady	boolean	No	true	Wait until index is ready before returning
embeddingModel	string	No*	-	Creates an index with integrated inference: multilingual-e5-large, llama-text-embed-v2, or pinecone-sparse-english-v0
textField	string	No	text	Document field to embed. Only used with embeddingModel

*Provide either dimension (standard index) or embeddingModel (integrated inference).

PINECONE_QUERY

Parameter	Type	Required	Default	Description
indexName	string	Yes	-	The name of the Pinecone index to query
vector	number[]	No*	-	Query vector as array of numbers
query	string	No*	-	Text query for integrated inference (automatic embedding)
topK	number	No	10	Number of results to return (1-100)
namespace	string	No	-	Namespace to query within the index
filter	object	No	-	Metadata filter using Pinecone filter syntax
minScore	number	No	-	Minimum similarity score threshold (0-1)
includeMetadata	boolean	No	true	Include metadata in results
includeValues	boolean	No	false	Include vector values in results
fields	string[]	No	-	Record fields to return (text queries). Must include every rerankRankFields entry
rerankModel	string	No	-	Reranking model: cohere-rerank-3.5, bge-reranker-v2-m3, or pinecone-rerank-v0
rerankTopN	number	No	-	Results to keep after reranking (must be ≤ topK)
rerankRankFields	string[]	No	-	Fields the reranker scores, e.g. ["text"]. Required with rerankModel
rerankQuery	string	No	-	Text to rerank against. Defaults to query

*Either vector or query must be provided, but not both.

PINECONE_UPSERT

Parameter	Type	Required	Default	Description
indexName	string	Yes	-	The name of the Pinecone index
vectors	array	No*	-	Array of vector objects (id, values, metadata)
documents	array	No*	-	Array of document objects for integrated inference (id, text, metadata)
namespace	string	No	-	Namespace for data organization

*Either vectors or documents must be provided, but not both.

Output

PINECONE_QUERY returns the following under result (steps.<id>.result.matches, and so on). PINECONE_UPSERT returns result.upsertedCount.

{
  "matches": [
    {
      "id": "vec1",
      "score": 0.95,
      "metadata": {
        "title": "Document Title",
        "text": "Document content...",
        "category": "technology"
      }
    }
  ],
  "namespace": "production",
  "usage": {
    "readUnits": 5
  }
}

Use Cases

RAG (Retrieval-Augmented Generation)

Combine Pinecone with an LLM tool such as OPENAI_INVOKE (see the RAG example above):

1. Search Pinecone with the user’s question as a text query (integrated inference), or with a vector generated outside Jinba Flow that matches the index dimension
2. Take the relevant documents from result.matches
3. Pass them as context in the LLM prompt

Semantic Search

Search documents by meaning rather than keywords:

• Find similar articles
• Recommend related content
• Discover relevant information

Question Answering

Build Q&A systems with context retrieval:

• Technical documentation search
• Customer support knowledge base
• Research paper discovery

Resources

• Pinecone Documentation
• Pinecone Console
• Vector Embeddings Guide
• RAG Best Practices