Skip to content

pinecone.types

Types for interacting with Pinecone using Mirascope.

BaseVectorStoreParams

Bases: BaseModel

The parameters with which to make a vectorstore.

Source code in mirascope/rag/types.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
class BaseVectorStoreParams(BaseModel):
    """The parameters with which to make a vectorstore."""

    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)

    def kwargs(
        self,
    ) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        kwargs = {
            key: value for key, value in self.model_dump().items() if value is not None
        }
        return kwargs

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/rag/types.py 
43
44
45
46
47
48
49
50
def kwargs(
    self,
) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    kwargs = {
        key: value for key, value in self.model_dump().items() if value is not None
    }
    return kwargs

PineconeParams

Bases: BaseModel

The parameters for Pinecone create_index

Source code in mirascope/pinecone/types.py 
45
46
47
48
49
50
51
52
53
54
55
56
class PineconeParams(BaseModel):
    """The parameters for Pinecone create_index"""

    metric: Optional[Literal["cosine", "dotproduct", "euclidean"]] = "cosine"
    timeout: Optional[int] = None

    def kwargs(self) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        kwargs = {
            key: value for key, value in self.model_dump().items() if value is not None
        }
        return kwargs

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/pinecone/types.py 
51
52
53
54
55
56
def kwargs(self) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    kwargs = {
        key: value for key, value in self.model_dump().items() if value is not None
    }
    return kwargs

PineconePodParams

Bases: PineconeParams, PodSpec, BaseVectorStoreParams

The parameters for Pinecone create_index with pod spec and weave

Source code in mirascope/pinecone/types.py 
69
70
71
72
73
74
75
76
77
class PineconePodParams(PineconeParams, PodSpec, BaseVectorStoreParams):
    """The parameters for Pinecone create_index with pod spec and weave"""

    def kwargs(self) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        pod_kwargs = PodSpec(**self.model_dump()).kwargs()
        pinecone_kwargs = PineconeParams(**self.model_dump()).kwargs()
        # print(pinecone_kwargs, serverless_kwargs)
        return {**pinecone_kwargs, "spec": {**pod_kwargs}}

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/pinecone/types.py 
72
73
74
75
76
77
def kwargs(self) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    pod_kwargs = PodSpec(**self.model_dump()).kwargs()
    pinecone_kwargs = PineconeParams(**self.model_dump()).kwargs()
    # print(pinecone_kwargs, serverless_kwargs)
    return {**pinecone_kwargs, "spec": {**pod_kwargs}}

PineconeQueryResult

Bases: BaseModel

The result of a Pinecone index query

Example:

from mirascope.pinecone import (
    PineconeServerlessParams,
    PineconeSettings,
    PineconeVectorStore,
)
from mirascope.openai import OpenAIEmbedder
from mirascope.rag import TextChunker


class MyStore(ChromaVectorStore):
    embedder = OpenAIEmbedder(dimensions=1536)
    chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
    index_name = "my-store-0001"
    api_key = settings.pinecone_api_key
    client_settings = PineconeSettings()
    vectorstore_params = PineconeServerlessParams(
        cloud="aws",
        region="us-west-2",
    )

my_store = MyStore()
with open(f"{PATH_TO_FILE}") as file:
    data = file.read()
    my_store.add(data)
query_results = my_store.retrieve("my question")
#> QueryResult(ids=['0'], documents=['my answer'],
# scores=[0.9999999999999999], embeddings=[[0.0, 0.0, 0.0, ...]])
Source code in mirascope/pinecone/types.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
class PineconeQueryResult(BaseModel):
    """The result of a Pinecone index query

    Example:

    ```python
    from mirascope.pinecone import (
        PineconeServerlessParams,
        PineconeSettings,
        PineconeVectorStore,
    )
    from mirascope.openai import OpenAIEmbedder
    from mirascope.rag import TextChunker


    class MyStore(ChromaVectorStore):
        embedder = OpenAIEmbedder(dimensions=1536)
        chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
        index_name = "my-store-0001"
        api_key = settings.pinecone_api_key
        client_settings = PineconeSettings()
        vectorstore_params = PineconeServerlessParams(
            cloud="aws",
            region="us-west-2",
        )

    my_store = MyStore()
    with open(f"{PATH_TO_FILE}") as file:
        data = file.read()
        my_store.add(data)
    query_results = my_store.retrieve("my question")
    #> QueryResult(ids=['0'], documents=['my answer'],
    # scores=[0.9999999999999999], embeddings=[[0.0, 0.0, 0.0, ...]])
    ```
    """

    ids: list[str]
    documents: Optional[list[str]] = None
    scores: Optional[list[float]] = None
    embeddings: Optional[list[list[float]]] = None

PineconeServerlessParams

Bases: PineconeParams, ServerlessSpec, BaseVectorStoreParams

The parameters for Pinecone create_index with serverless spec and weave

Source code in mirascope/pinecone/types.py 
59
60
61
62
63
64
65
66
class PineconeServerlessParams(PineconeParams, ServerlessSpec, BaseVectorStoreParams):
    """The parameters for Pinecone create_index with serverless spec and weave"""

    def kwargs(self) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        serverless_kwargs = ServerlessSpec(**self.model_dump()).kwargs()
        pinecone_kwargs = PineconeParams(**self.model_dump()).kwargs()
        return {**pinecone_kwargs, "spec": {**serverless_kwargs}}

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/pinecone/types.py 
62
63
64
65
66
def kwargs(self) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    serverless_kwargs = ServerlessSpec(**self.model_dump()).kwargs()
    pinecone_kwargs = PineconeParams(**self.model_dump()).kwargs()
    return {**pinecone_kwargs, "spec": {**serverless_kwargs}}

PineconeSettings

Bases: BaseModel

Settings for Pinecone instance

Source code in mirascope/pinecone/types.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
class PineconeSettings(BaseModel):
    """Settings for Pinecone instance"""

    api_key: Optional[str] = None
    host: Optional[str] = None
    proxy_url: Optional[str] = None
    proxy_headers: Optional[dict[str, str]] = None
    ssl_ca_certs: Optional[str] = None
    ssl_verify: Optional[bool] = None
    config: Optional[Config] = None
    additional_headers: Optional[dict[str, str]] = {}
    pool_threads: Optional[int] = 1
    index_api: Optional[ManageIndexesApi] = None

    model_config = ConfigDict(arbitrary_types_allowed=True)

    def kwargs(self) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        kwargs = {
            key: value for key, value in self.model_dump().items() if value is not None
        }
        return kwargs

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/pinecone/types.py 
 96
 97
 98
 99
100
101
def kwargs(self) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    kwargs = {
        key: value for key, value in self.model_dump().items() if value is not None
    }
    return kwargs

PodSpec

Bases: BaseModel

The parameters for Pinecone PodSpec

Source code in mirascope/pinecone/types.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class PodSpec(BaseModel):
    """The parameters for Pinecone PodSpec"""

    environment: str
    replicas: Optional[int] = None
    shards: Optional[int] = None
    pods: Optional[int] = None
    pod_type: Optional[str] = "p1.x1"
    metadata_config: Optional[dict] = {}
    source_collection: Optional[str] = None

    def kwargs(self) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        kwargs = {
            key: value for key, value in self.model_dump().items() if value is not None
        }
        return {"pod": kwargs}

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/pinecone/types.py 
37
38
39
40
41
42
def kwargs(self) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    kwargs = {
        key: value for key, value in self.model_dump().items() if value is not None
    }
    return {"pod": kwargs}

ServerlessSpec

Bases: BaseModel

The parameters for Pinecone ServerlessSpec

Source code in mirascope/pinecone/types.py 
12
13
14
15
16
17
18
19
20
21
22
23
class ServerlessSpec(BaseModel):
    """The parameters for Pinecone ServerlessSpec"""

    cloud: str
    region: str

    def kwargs(self) -> dict[str, Any]:
        """Returns all parameters for the index as a keyword arguments dictionary."""
        kwargs = {
            key: value for key, value in self.model_dump().items() if value is not None
        }
        return {"serverless": kwargs}

kwargs()

Returns all parameters for the index as a keyword arguments dictionary.

Source code in mirascope/pinecone/types.py 
18
19
20
21
22
23
def kwargs(self) -> dict[str, Any]:
    """Returns all parameters for the index as a keyword arguments dictionary."""
    kwargs = {
        key: value for key, value in self.model_dump().items() if value is not None
    }
    return {"serverless": kwargs}