# Running upsert on Pinecone
upsert_documents(
    index=index,
    contents=contents,
    metadatas=metadatas,
    embedder=openai_embeddings,
    sparse_encoder=sparse_encoder,
    namespace=namespace,
    batch_size=batch_size,
)

from langchain_openai import OpenAIEmbeddings

openai_embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

# Please set
embedder = openai_embeddings
batch_size = 32
namespace = "langchain-opentutorial-01"

# Running upsert on Pinecone
upsert_documents(
    index=index,
    contents=contents,
    metadatas=metadatas,
    embedder=openai_embeddings,
    sparse_encoder=sparse_encoder,
    namespace=namespace,
    batch_size=batch_size,
)

---------------------------------------------------------------------------
_InactiveRpcError                         Traceback (most recent call last)
File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/pinecone/grpc/grpc_runner.py:43, in GrpcRunner.run.<locals>.wrapped()
     42 try:
---> 43     return func(
     44         request,
     45         timeout=timeout,
     46         metadata=_metadata,
     47         credentials=credentials,
     48         wait_for_ready=wait_for_ready,
     49         compression=compression,
     50     )
     51 except _InactiveRpcError as e:

File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/grpc/_channel.py:1181, in _UnaryUnaryMultiCallable.__call__(self, request, timeout, metadata, credentials, wait_for_ready, compression)
   1175 (
   1176     state,
   1177     call,
   1178 ) = self._blocking(
   1179     request, timeout, metadata, credentials, wait_for_ready, compression
   1180 )
-> 1181 return _end_unary_response_blocking(state, call, False, None)

File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/grpc/_channel.py:1006, in _end_unary_response_blocking(state, call, with_call, deadline)
   1005 else:
-> 1006     raise _InactiveRpcError(state)

_InactiveRpcError: <_InactiveRpcError of RPC that terminated with:
	status = StatusCode.UNAUTHENTICATED
	details = "Unauthorized"
	debug_error_string = "UNKNOWN:Error received from peer  {grpc_message:"Unauthorized", grpc_status:16, created_time:"2025-01-19T18:23:50.281527+09:00"}"
>

The above exception was the direct cause of the following exception:

PineconeException                         Traceback (most recent call last)
Cell In[53], line 11
      8 namespace = "langchain-opentutorial-01"
     10 # Running upsert on Pinecone
---> 11 upsert_documents(
     12     index=index,
     13     contents=contents,
     14     metadatas=metadatas,
     15     embedder=openai_embeddings,
     16     sparse_encoder=sparse_encoder,
     17     namespace=namespace,
     18     batch_size=batch_size,
     19 )

Cell In[52], line 47
     30     vectors = [
     31         {
     32             "id": f"doc-{batch_start + i}",
   (...)
     43         for i, content in enumerate(context_batch)
     44     ]
     46     # Upsert to Pinecone
---> 47     index.upsert(vectors=vectors, namespace=namespace)
     49 print(index.describe_index_stats())

File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/pinecone/grpc/index_grpc.py:143, in GRPCIndex.upsert(self, vectors, async_req, namespace, batch_size, show_progress, **kwargs)
    140     return PineconeGrpcFuture(future)
    142 if batch_size is None:
--> 143     return self._upsert_batch(vectors, namespace, timeout=timeout, **kwargs)
    145 if not isinstance(batch_size, int) or batch_size <= 0:
    146     raise ValueError("batch_size must be a positive integer")

File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/pinecone/grpc/index_grpc.py:165, in GRPCIndex._upsert_batch(self, vectors, namespace, timeout, **kwargs)
    163 args_dict = self._parse_non_empty_args([("namespace", namespace)])
    164 request = UpsertRequest(vectors=vectors, **args_dict)
--> 165 return self.runner.run(self.stub.Upsert, request, timeout=timeout, **kwargs)

File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/pinecone/grpc/grpc_runner.py:54, in GrpcRunner.run(self, func, request, timeout, metadata, credentials, wait_for_ready, compression)
     51     except _InactiveRpcError as e:
     52         raise PineconeException(e._state.debug_error_string) from e
---> 54 return wrapped()

File ~/Library/Caches/pypoetry/virtualenvs/langchain-opentutorial-bT98fzkt-py3.11/lib/python3.11/site-packages/pinecone/grpc/grpc_runner.py:52, in GrpcRunner.run.<locals>.wrapped()
     43     return func(
     44         request,
     45         timeout=timeout,
   (...)
     49         compression=compression,
     50     )
     51 except _InactiveRpcError as e:
---> 52     raise PineconeException(e._state.debug_error_string) from e

PineconeException: UNKNOWN:Error received from peer  {grpc_message:"Unauthorized", grpc_status:16, created_time:"2025-01-19T18:23:50.281527+09:00"}

import os, time
from pinecone.grpc import PineconeGRPC as Pinecone
from pinecone import ServerlessSpec, PodSpec

# Initialize Pinecone client with API key from environment variables
pc = Pinecone(api_key=os.environ.get("PINECONE_API_KEY"))

# Set to True when using the serverless method, and False when using the PodSpec method.
use_serverless = True

if use_serverless:
    spec = ServerlessSpec(cloud="aws", region="us-east-1")
else:
    spec = PodSpec(environment="us-west1-gcp", pod_type="p1.x1", pods=1)

index_name = "langchain-opentutorial-index"

# Check existing index name
all_indexes = pc.list_indexes()
print(f"Full Index Data: {all_indexes}")
existing_indexes = [index.name for index in all_indexes]
print(f"Extracted Index Names: {existing_indexes}")

# Check existing index and handle deletion/creation
if index_name in existing_indexes:
    print(f"Using existing index: {index_name}")
    index = pc.Index(index_name)
else:
    print(f"Creating new index: {index_name}")
    pc.create_index(
        index_name,
        dimension=3072,
        metric="dotproduct",
        spec=spec,
    )
    index = pc.Index(index_name)

# Check index readiness
while not pc.describe_index(index_name).status["ready"]:
    time.sleep(1)
print(f"Index '{index_name}' is ready.")