feat: upgraded to Pinecone v7

.dagger/src/semantic_router_ci/main.py

@@ -97,10 +97,7 @@ async def test(
         pinecone_api_key: str = "",
         python_version: str = "3.11",
     ) -> str:
-        """Runs tests for semantic-router, scope can be
-        set to run for 'unit', 'functional', 'integration',
-        or 'all'. By default scope is set to 'unit'.
-        """
+        """Runs tests for semantic-router. Scope: 'unit' (default), 'functional', 'integration', or 'all'."""
         # Map scope to pytest arguments
         if scope == "all":
             pytest_args = [
@@ -164,10 +161,34 @@ async def test(
             container = container.with_env_variable(
                 "PINECONE_API_KEY", pinecone_api_key
             )
+        # Forward optional shared index name to the test container
+        pinecone_index_name = os.environ.get("PINECONE_INDEX_NAME")
+        if pinecone_index_name:
+            container = container.with_env_variable(
+                "PINECONE_INDEX_NAME", pinecone_index_name
+            )
+        container = container.with_service_binding("postgres", self.postgres_service())
+        pinecone_api_base_url = os.environ.get("PINECONE_API_BASE_URL")
+        # Decide cloud vs local
+        if pinecone_api_base_url is None:
+            # No explicit base URL provided; infer from API key
+            if pinecone_api_key and pinecone_api_key != "pclocal":
+                # Real key provided: prefer cloud
+                pinecone_api_base_url = "https://api.pinecone.io"
+            else:
+                # Local mode
+                pinecone_api_base_url = "http://pinecone:5080"
+        # Start local emulator only if pointing to local
+        if (
+            pinecone_api_base_url.startswith("http://pinecone:5080")
+            or "localhost" in pinecone_api_base_url
+        ):
+            container = container.with_service_binding(
+                "pinecone", self.pinecone_service()
+            )
+        # Set env vars inside test container
         container = (
-            container.with_service_binding("postgres", self.postgres_service())
-            .with_service_binding("pinecone", self.pinecone_service())
-            .with_env_variable("PINECONE_API_BASE_URL", "http://pinecone:5080")
+            container.with_env_variable("PINECONE_API_BASE_URL", pinecone_api_base_url)
             .with_env_variable(
                 "POSTGRES_HOST", os.environ.get("POSTGRES_HOST", "postgres")
             )
@@ -180,7 +201,5 @@ async def test(
                 "POSTGRES_PASSWORD", os.environ.get("POSTGRES_PASSWORD", "postgres")
             )
         )
-        # Debug: print env vars inside the container
-        container = container.with_exec(["env"])
         container = container.with_exec(pytest_args)
         return await container.stdout()

.github/workflows/test.yml

@@ -19,6 +19,12 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
+    env:
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
+      PINECONE_API_KEY: ${{ secrets.PINECONE_API_KEY }}
+      # If you have a shared Pinecone index, set this secret to reuse it in CI
+      PINECONE_INDEX_NAME: ${{ secrets.PINECONE_INDEX_NAME }}
     timeout-minutes: 20  # Fail the job if it runs longer than 20 minutes
     strategy:
       matrix:
@@ -49,11 +55,7 @@ jobs:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
           PINECONE_API_KEY: ${{ secrets.PINECONE_API_KEY }}
-          POSTGRES_HOST: postgres
-          POSTGRES_PORT: 5432
-          POSTGRES_DB: postgres
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
+          PINECONE_INDEX_NAME: ${{ secrets.PINECONE_INDEX_NAME }}
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v2

docs/user-guide/guides/pinecone-v7.md

@@ -0,0 +1,112 @@
+## Pinecone v7 integration
+
+This guide shows how to use Semantic Router with the Pinecone Python SDK v7+, including cloud vs local setup, shared-index reuse, and namespaces for isolation.
+
+### Install
+
+```bash
+pip install "semantic-router[pinecone]"
+```
+
+### Environment variables
+
+- `PINECONE_API_KEY` (required): Your Pinecone API key
+- `PINECONE_API_BASE_URL` (optional):
+  - Cloud: `https://api.pinecone.io` (default if a real API key is set)
+  - Local emulator: `http://localhost:5080` or `http://pinecone:5080`
+- `PINECONE_INDEX_NAME` (recommended on cloud): Name of an existing index to reuse
+
+Why set `PINECONE_INDEX_NAME`? Pinecone serverless has per-project index limits. Reusing a shared index avoids 403 quota errors. Semantic Router will automatically isolate data using namespaces.
+
+### Basic usage (cloud)
+
+```python
+import os
+from semantic_router.encoders import OpenAIEncoder
+from semantic_router.index.pinecone import PineconeIndex
+from semantic_router.route import Route
+from semantic_router.routers import SemanticRouter
+
+# Required
+os.environ["PINECONE_API_KEY"] = "<your-key>"
+
+# Strongly recommended: reuse an existing index to avoid quota
+os.environ["PINECONE_INDEX_NAME"] = "semantic-router-shared"
+
+encoder = OpenAIEncoder(name="text-embedding-3-small")
+
+# Use a namespace for isolation (otherwise the router will use the requested
+# index name internally as the namespace when reusing a shared index)
+index = PineconeIndex(index_name="demo-index", namespace="demo", dimensions=1536)
+
+routes = [
+    Route(name="greeting", utterances=["hello", "hi"]),
+    Route(name="goodbye", utterances=["bye", "goodbye"]),
+]
+
+router = SemanticRouter(encoder=encoder, routes=routes, index=index, auto_sync="local")
+
+print(router(text="hi there").name)  # -> greeting
+```
+
+Notes:
+- If the shared index exists, Semantic Router reuses it and writes route vectors under your `namespace`.
+- If you do not set `PINECONE_INDEX_NAME`, creating a new index requires `dimensions`. If index creation is forbidden (quota), a clear error is raised asking you to set `PINECONE_INDEX_NAME`.
+- You do not need to set `PINECONE_API_BASE_URL` for cloud; override it only when using the local emulator for testing.
+
+### Local emulator
+
+```bash
+export PINECONE_API_KEY=pclocal
+export PINECONE_API_BASE_URL=http://localhost:5080
+```
+
+In local mode, Semantic Router connects to the emulator at `http://localhost:5080` (or `http://pinecone:5080` in containerized CI) and adds a short delay after create to account for readiness.
+
+### Async usage
+
+```python
+import asyncio
+from semantic_router.routers import SemanticRouter
+
+async def main():
+    result = await router.acall("hello")
+    print(result.name)
+
+asyncio.run(main())
+```
+
+Internally, the library resolves the Pinecone v7 data-plane host and uses the correct `/vectors/query` endpoint for async queries.
+
+### Error handling and retries
+
+- 403 (quota): The library attempts to reuse an existing index. If none is available, it raises an error advising you to set `PINECONE_INDEX_NAME`.
+- 404 (eventual consistency): Readiness checks and upserts include brief bounded retries.
+
+### CI tips (GitHub Actions)
+
+- Set secrets:
+  - `PINECONE_API_KEY`
+  - `PINECONE_INDEX_NAME` (existing shared index)
+- Ensure the environment uses cloud:
+
+```yaml
+env:
+  PINECONE_API_KEY: ${{ secrets.PINECONE_API_KEY }}
+  PINECONE_INDEX_NAME: ${{ secrets.PINECONE_INDEX_NAME }}
+
+steps:
+  - name: Run tests
+    run: |
+      PINECONE_API_BASE_URL="https://api.pinecone.io" \ 
+      pytest -q
+```
+
+Tests that require Pinecone will automatically skip in cloud mode if `PINECONE_INDEX_NAME` isn’t provided, avoiding quota-based failures.
+
+### Requirements recap
+
+- Pinecone Python client v7+
+- Semantic Router ≥ version including Pinecone v7 support (this branch)
+- Recommended on cloud: `PINECONE_INDEX_NAME` pointing at an existing index
+

pyproject.toml

@@ -31,13 +31,13 @@ local = [
     "sentence-transformers>=5.0.0 ; python_version < '3.13'",
     "torch>=2.6.0 ; python_version < '3.13'"
 ]
+pinecone = ["pinecone>=7.0.0,<8.0.0"]
 vision = [
     "torchvision>=0.17.0 ; python_version < '3.13'",
     "transformers>=4.36.2 ; python_version < '3.13'",
     "pillow>=10.2.0,<11.0.0 ; python_version < '3.13'",
     "torch>=2.6.0 ; python_version < '3.13'"
 ]
-pinecone = ["pinecone>=5.0.0,<6.0.0"]
 mistralai = ["mistralai>=0.0.12,<0.1.0"]
 qdrant = ["qdrant-client>=1.11.1,<2"]
 google = ["google-cloud-aiplatform>=1.45.0,<2"]

semantic_router/index/hybrid_local.py

@@ -16,7 +16,6 @@ class HybridLocalIndex(LocalIndex):
     def __init__(self, **data):
         super().__init__(**data)
         self.metadata = None
-
 
     def add(
         self,