> ## Documentation Index
> Fetch the complete documentation index at: https://docs.modulex.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Pinecone vector store (BYOK)

> Connect Pinecone as a bring-your-own vector store in ModuleX: store an API key credential, configure a knowledge node, and run BYOK vector retrieval inside workflows.

export const MediaEmbed = ({id, type = 'screenshot', caption = '', ext, ratio = '16 / 9'}) => {
  const isVideo = type === 'video' || type === 'app_video';
  const resolvedExt = ext || (isVideo ? 'mp4' : type === 'screenshot' ? 'webp' : 'svg');
  const src = 'https://media.modulex.dev/' + id + '.' + resolvedExt;
  const [status, setStatus] = useState('loading');
  const [isDev, setIsDev] = useState(false);
  const [inView, setInView] = useState(false);
  const boxRef = useRef(null);
  useEffect(() => {
    if (typeof window === 'undefined') return;
    const h = window.location.hostname;
    setIsDev(h === 'localhost' || h === '127.0.0.1' || h.endsWith('.mintlify.app'));
  }, []);
  useEffect(() => {
    if (inView) return;
    if (typeof IntersectionObserver === 'undefined') {
      setInView(true);
      return;
    }
    const el = boxRef.current;
    if (!el) return;
    const io = new IntersectionObserver(entries => {
      if (entries.some(e => e.isIntersecting)) {
        setInView(true);
        io.disconnect();
      }
    }, {
      rootMargin: '300px'
    });
    io.observe(el);
    return () => io.disconnect();
  }, [inView]);
  if (status === 'missing') {
    if (!isDev) return null;
    return <div style={{
      display: 'flex',
      flexDirection: 'column',
      justifyContent: 'center',
      gap: '0.4rem',
      padding: '1rem 1.25rem',
      margin: '1.25rem 0',
      width: '100%',
      aspectRatio: ratio,
      boxSizing: 'border-box',
      border: '1px dashed rgba(128,128,128,0.45)',
      borderRadius: '0.75rem',
      background: 'rgba(128,128,128,0.06)',
      color: 'currentColor',
      fontSize: '0.85rem',
      lineHeight: 1.45
    }}>
        <div style={{
      display: 'flex',
      alignItems: 'center',
      gap: '0.5rem',
      opacity: 0.75
    }}>
          <span aria-hidden="true">🎬</span>
          <code style={{
      fontSize: '0.75rem'
    }}>{id}</code>
          <span style={{
      fontSize: '0.65rem',
      textTransform: 'uppercase',
      letterSpacing: '0.04em',
      padding: '0.1rem 0.4rem',
      borderRadius: '0.4rem',
      background: 'rgba(128,128,128,0.18)'
    }}>
            {type}
          </span>
        </div>
        <div style={{
      opacity: 0.9
    }}>{caption || 'Media not uploaded yet.'}</div>
        <div style={{
      fontSize: '0.7rem',
      opacity: 0.5
    }}>
          Upload to R2 as <code>{id}.{resolvedExt}</code> — preview only, hidden in production.
        </div>
      </div>;
  }
  const mediaStyle = {
    display: status === 'loaded' ? 'block' : 'none',
    width: '100%',
    height: 'auto',
    borderRadius: '0.75rem'
  };
  const media = isVideo ? <video src={inView ? src : undefined} autoPlay loop muted playsInline preload="metadata" onLoadedData={() => setStatus('loaded')} onError={() => setStatus('missing')} style={mediaStyle} /> : <img src={inView ? src : undefined} alt={caption} onLoad={() => setStatus('loaded')} onError={() => setStatus('missing')} style={mediaStyle} />;
  return <figure style={{
    margin: '1.25rem 0'
  }}>
      <div ref={boxRef} style={status === 'loaded' ? {
    width: '100%'
  } : {
    width: '100%',
    aspectRatio: ratio,
    borderRadius: '0.75rem',
    background: 'rgba(128,128,128,0.06)'
  }}>
        {media}
      </div>
      {status === 'loaded' && caption ? <figcaption style={{
    marginTop: '0.5rem',
    textAlign: 'center',
    fontSize: '0.85rem',
    opacity: 0.7
  }}>
          {caption}
        </figcaption> : null}
    </figure>;
};

Pinecone is a managed vector database you can bring to ModuleX as an external [knowledge provider](/integrations/knowledge-providers/overview). When you connect Pinecone, ModuleX queries **your** Pinecone index at retrieval time using a stored credential — your vectors stay in your Pinecone project, and Pinecone bills you directly. This is the **bring-your-own-key (BYOK)** model: unlike [managed knowledge (modulexdb)](/integrations/knowledge-providers/modulexdb), BYOK retrieval through Pinecone is **not** metered in ModuleX credits.

Use this page to store a Pinecone credential, configure a [knowledge node](/workflow-builder/nodes/knowledge) to point at your index, and understand exactly how ModuleX issues the query.

<Note>
  Pinecone is a **retrieval-only** provider in ModuleX. ModuleX queries an index you already populated; it does **not** upload, chunk, embed, or ingest documents into Pinecone for you. Document ingest (parse, chunk, embed) only applies to [managed knowledge bases](/platform/knowledge/managed). For Pinecone you own the indexing pipeline.
</Note>

## How BYOK retrieval works

At a high level, a Pinecone-backed retrieval inside a workflow runs in five steps:

<Steps>
  <Step title="Resolve the credential">
    The [knowledge node](/workflow-builder/nodes/knowledge) reads its `credential_id`, loads the matching org credential, and decrypts the stored `auth_data` (your `api_key` and `environment`).
  </Step>

  <Step title="Embed the query">
    Pinecone stores vectors but does not embed text. ModuleX generates a query embedding first, using the node's `embedding_config` (for example OpenAI `text-embedding-3-small`). If `embedding_config` is missing, the node fails before any call to Pinecone.
  </Step>

  <Step title="Call your index">
    ModuleX `POST`s the query vector to your Pinecone index endpoint with your `Api-Key` header, requesting `topK` matches in the configured `namespace`, with any metadata `filter` applied.
  </Step>

  <Step title="Normalize the matches">
    Each Pinecone match is mapped into a standard result with `id`, `score`, `content` (pulled from common metadata text fields), and `metadata`. Matches below `min_score` are dropped client-side.
  </Step>

  <Step title="Format the output">
    Results are returned to the workflow as `chunks`, a formatted `context` string, or `both`, depending on the node's `output_format`.
  </Step>
</Steps>

<MediaEmbed id="MX-MEDIA-4140" type="image" caption={"BYOK retrieval flow diagram for Pinecone."} />

## Before you start

You will need the following from your own Pinecone account:

<Card title="Pinecone prerequisites" icon="key">
  * A **Pinecone API key**. Pinecone keys look like `pcsk_...`.
  * The **environment** for your project (for example `us-east-1-aws` or `gcp-starter`).
  * An existing, **populated index** whose vector dimension matches the embedding model you plan to use in ModuleX. A 1536-dimension index pairs with OpenAI `text-embedding-3-small`; mismatched dimensions cause Pinecone to reject the query.
  * The index `namespace` you want to search, if you use namespaces.
</Card>

You also need the **owner** or **admin** role in the ModuleX organization. Credential and knowledge routes require an admin/owner role; the retired `member` role cannot manage them. See [roles & permissions](/security/roles-permissions).

## Connect Pinecone

Connecting Pinecone means storing an encrypted credential in your organization. ModuleX persists it as a **custom** credential (`auth_type` is `custom`) under the `pinecone` integration, which the catalog classifies as a `knowledge_provider`.

### Credential fields

Pinecone declares a single `custom` auth schema with two fields:

<ParamField path="api_key" type="string" required>
  Your Pinecone API key. Stored encrypted and never returned in plaintext. Sample format `pcsk_...`. This is the `Api-Key` header value ModuleX sends on every request to Pinecone.
</ParamField>

<ParamField path="environment" type="string" required>
  Your Pinecone environment, for example `us-east-1-aws` or `gcp-starter`. ModuleX uses it to build the Pinecone host URL (see [Index URL resolution](#index-url-resolution)).
</ParamField>

<ParamField path="index_host" type="string">
  Optional, undocumented in the connect UI. If present in `auth_data`, this exact URL overrides the environment-derived index host. Set this when your index host does not match the legacy `environment`-based pattern — for example for serverless indexes. See [Index URL resolution](#index-url-resolution) for why this matters. {/* TODO: index_host is read by pinecone_adapter.py:59-60 but is not a declared manifest field; confirm whether the connect UI exposes it. */}
</ParamField>

### Connect in the app

<Steps>
  <Step title="Open knowledge providers">
    In the ModuleX app, go to the integrations area and select **Pinecone** under knowledge providers.
  </Step>

  <Step title="Enter your credentials">
    Paste your Pinecone **API key** and **environment**, give the credential a display name, and optionally mark it as the default for Pinecone.
  </Step>

  <Step title="Test the connection">
    ModuleX validates the credential by listing your indexes (`GET https://api.pinecone.io/indexes`). A `200` with an `indexes` field means the key works. This test is free.
  </Step>
</Steps>

<MediaEmbed id="MX-MEDIA-4141" type="screenshot" caption={"The Pinecone connect form in the ModuleX app."} />

### Connect via the API

Create the credential with [`POST /credentials`](/api-reference/overview). The request body is read raw and the credential type is inferred from `integration_name`, `auth_type`, and `auth_data`. For Pinecone, send `auth_type: custom` with both fields nested under `auth_data`. ModuleX resolves `integration_type` to `knowledge_provider` from the catalog automatically.

All requests authenticate with `Authorization: Bearer mx_live_…` plus the `X-Organization-ID` header. See [authentication](/api-reference/authentication).

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.modulex.dev/credentials \
    -H "Authorization: Bearer mx_live_xxx" \
    -H "X-Organization-ID: org_123" \
    -H "Content-Type: application/json" \
    -d '{
      "integration_name": "pinecone",
      "auth_type": "custom",
      "display_name": "Production Pinecone",
      "make_default": true,
      "auth_data": {
        "api_key": "pcsk_xxx",
        "environment": "us-east-1-aws"
      }
    }'
  ```

  ```python Python theme={null}
  import httpx

  resp = httpx.post(
      "https://api.modulex.dev/credentials",
      headers={
          "Authorization": "Bearer mx_live_xxx",
          "X-Organization-ID": "org_123",
      },
      json={
          "integration_name": "pinecone",
          "auth_type": "custom",
          "display_name": "Production Pinecone",
          "make_default": True,
          "auth_data": {
              "api_key": "pcsk_xxx",
              "environment": "us-east-1-aws",
          },
      },
  )
  resp.raise_for_status()
  credential = resp.json()
  print(credential["credential_id"])
  ```

  ```javascript JavaScript theme={null}
  const resp = await fetch("https://api.modulex.dev/credentials", {
    method: "POST",
    headers: {
      Authorization: "Bearer mx_live_xxx",
      "X-Organization-ID": "org_123",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      integration_name: "pinecone",
      auth_type: "custom",
      display_name: "Production Pinecone",
      make_default: true,
      auth_data: {
        api_key: "pcsk_xxx",
        environment: "us-east-1-aws",
      },
    }),
  });
  if (!resp.ok) throw new Error(`Create credential failed: ${resp.status}`);
  const credential = await resp.json();
  console.log(credential.credential_id);
  ```
</CodeGroup>

<Note>
  Creating, listing, and querying a Pinecone credential is a plain CRUD operation, so it returns the standard `{detail}` error envelope on failure (for example a `400` `"Invalid auth_data or auth_type…"` if the body is malformed). The flat billing `DenialEnvelope` does **not** apply here. See [errors & status codes](/api-reference/errors) for the full envelope reference. Pinecone credentials are stored with `auth_type` `custom`, so they appear in your credential list (only `internal` credentials are hidden).
</Note>

#### Create-credential request fields

<ParamField path="integration_name" type="string" required>
  Must be `pinecone`. ModuleX looks this up in the integration catalog to resolve `integration_type` to `knowledge_provider`. An unknown name falls back to `tool`.
</ParamField>

<ParamField path="auth_type" type="string" required>
  Must be `custom` for Pinecone. This routes the request to the custom-credential path, which stores arbitrary `auth_data` fields.
</ParamField>

<ParamField path="auth_data" type="object" required>
  The Pinecone credential fields. Must not be empty. Carries `api_key` and `environment` (and optionally `index_host`).
</ParamField>

<ParamField path="display_name" type="string">
  A human-readable label for the credential. Defaults to `Pinecone Custom Credential` if omitted.
</ParamField>

<ParamField path="make_default" type="boolean" default="false">
  When `true`, sets this credential as the default for the `pinecone` integration, unsetting any prior default.
</ParamField>

#### Test the saved credential

Validate a stored credential against Pinecone with `POST /credentials/{credential_id}/test`. ModuleX calls the integration's test endpoint — `GET https://api.pinecone.io/indexes` — and reports whether the key is valid.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.modulex.dev/credentials/cred_abc/test \
    -H "Authorization: Bearer mx_live_xxx" \
    -H "X-Organization-ID: org_123"
  ```

  ```python Python theme={null}
  import httpx

  resp = httpx.post(
      "https://api.modulex.dev/credentials/cred_abc/test",
      headers={
          "Authorization": "Bearer mx_live_xxx",
          "X-Organization-ID": "org_123",
      },
  )
  print(resp.json()["is_valid"])
  ```

  ```javascript JavaScript theme={null}
  const resp = await fetch(
    "https://api.modulex.dev/credentials/cred_abc/test",
    {
      method: "POST",
      headers: {
        Authorization: "Bearer mx_live_xxx",
        "X-Organization-ID": "org_123",
      },
    },
  );
  const result = await resp.json();
  console.log(result.is_valid);
  ```
</CodeGroup>

A successful test response has the shape `{credential_id, is_valid, message, tested_at}`.

## Configure a knowledge node

Once the credential exists, point a [knowledge node](/workflow-builder/nodes/knowledge) at your Pinecone index by setting `provider_type` to `pinecone` and supplying the index name, an embedding configuration, and the credential.

Because Pinecone stores only vectors, the knowledge node **requires** an `embedding_config` for Pinecone. ModuleX uses it to embed the query text before calling Pinecone. If `embedding_config` is omitted, the node raises a validation error and never reaches Pinecone.

### Knowledge node fields for Pinecone

<ParamField path="credential_id" type="string" required>
  The `credential_id` of your stored Pinecone credential.
</ParamField>

<ParamField path="provider_type" type="string" default="modulexdb" required>
  Set to `pinecone`. Valid knowledge provider types are `modulexdb`, `qdrant`, `pinecone`, `weaviate`, and `mongodb_atlas`.
</ParamField>

<ParamField path="collection_name" type="string" required>
  The Pinecone **index name** to search. ModuleX uses Pinecone's `index_name` terminology here as `collection_name`. Required for all external providers; the node fails with `"collection_name is required for external provider: pinecone"` if it is missing.
</ParamField>

<ParamField path="embedding_config" type="object" required>
  Embedding settings used to turn the query text into a vector. Required for Pinecone because Pinecone does not embed text. See [Embedding configuration](#embedding-configuration) for fields. Use a model whose output dimension matches your Pinecone index.
</ParamField>

<ParamField path="query" type="string" required>
  The search query. Supports `{{nodeId.path}}` references so the query can come from an earlier node's output.
</ParamField>

<ParamField path="query_from_input" type="boolean" default="false">
  When `true`, the workflow input is used as the query instead of the `query` field.
</ParamField>

<ParamField path="namespace" type="string">
  The Pinecone namespace to search within the index. Omit to search the default namespace.
</ParamField>

<ParamField path="top_k" type="integer" default="5">
  Number of matches to return. Range 1–50. Sent to Pinecone as `topK`.
</ParamField>

<ParamField path="min_score" type="number" default="0.3">
  Minimum similarity score, 0.0–1.0. Pinecone has no native score threshold, so ModuleX drops matches below this value **after** Pinecone returns them. The score is Pinecone's raw match score for your index's metric; ModuleX does not re-normalize it.
</ParamField>

<ParamField path="filters" type="object">
  A Pinecone metadata filter, passed through to Pinecone's query `filter` field verbatim. Use Pinecone filter syntax, for example `{"category": {"$eq": "docs"}}`.
</ParamField>

<ParamField path="max_tokens" type="integer" default="2000">
  Token budget for the formatted context string. Range 100–10000. Only applies when `output_format` is `context` or `both`.
</ParamField>

<ParamField path="output_format" type="string" default="context">
  How results are returned: `chunks` (individual matches with metadata), `context` (a single RAG-ready string), or `both`.
</ParamField>

<ParamField path="include_metadata" type="boolean" default="true">
  Include each match's metadata in the result. ModuleX requests `includeMetadata` from Pinecone accordingly.
</ParamField>

<ParamField path="include_source" type="boolean" default="true">
  Include source document headers in the formatted `context` output.
</ParamField>

<ParamField path="document_ids" type="array">
  Filter to specific document IDs. **Native (modulexdb) KB only** — ignored for Pinecone. Use `filters` for Pinecone-side metadata filtering instead.
</ParamField>

### Embedding configuration

The `embedding_config` object tells ModuleX which model to use when embedding the query. The model's output dimension must match your Pinecone index dimension.

<ParamField path="integration_name" type="string" required>
  The embedding provider integration, for example `openai` or `cohere`.
</ParamField>

<ParamField path="provider_id" type="string" required>
  The provider identifier, for example `openai`.
</ParamField>

<ParamField path="model_id" type="string" required>
  The embedding model id, for example `text-embedding-3-small` (1536 dimensions) or `text-embedding-3-large` (3072 dimensions).
</ParamField>

<ParamField path="credential_id" type="string">
  Credential for the embedding provider. If `null`, ModuleX uses your organization's default credential for that integration.
</ParamField>

<Warning>
  Dimension mismatch is the most common Pinecone failure. If your index was created at 1536 dimensions, the `embedding_config.model_id` must produce 1536-dimension vectors. A mismatch produces a Pinecone query error surfaced as a `500` with the message `"Pinecone query failed: …"`.
</Warning>

### Example knowledge node configuration

A workflow knowledge node configured for Pinecone looks like this:

```json Pinecone knowledge node config theme={null}
{
  "credential_id": "cred_abc",
  "provider_type": "pinecone",
  "collection_name": "product-docs",
  "namespace": "v1",
  "query": "{{trigger.question}}",
  "top_k": 5,
  "min_score": 0.3,
  "filters": { "category": { "$eq": "docs" } },
  "output_format": "context",
  "embedding_config": {
    "integration_name": "openai",
    "provider_id": "openai",
    "model_id": "text-embedding-3-small",
    "credential_id": null
  }
}
```

<MediaEmbed id="MX-MEDIA-4142" type="screenshot" caption={"Knowledge node inspector configured for Pinecone."} />

## How ModuleX queries Pinecone

When the knowledge node runs, ModuleX builds and sends the Pinecone query directly. Understanding the exact request helps when debugging connectivity or 404s.

### Request to Pinecone

ModuleX `POST`s to `{index_url}/query` with these headers:

```http Headers sent to Pinecone theme={null}
Api-Key: <your api_key>
Content-Type: application/json
```

and this body:

```json Pinecone query body theme={null}
{
  "vector": [0.0123, -0.0456, "..."],
  "topK": 5,
  "includeMetadata": true,
  "includeValues": false,
  "namespace": "v1",
  "filter": { "category": { "$eq": "docs" } }
}
```

`namespace` and `filter` are only included when set. The request times out after 30 seconds.

### Index URL resolution

ModuleX builds the index host in this order:

<Expandable title="Index host resolution rules">
  1. If your credential `auth_data` contains `index_host`, ModuleX uses that exact URL.
  2. Otherwise, ModuleX derives the host from the environment as `https://{index_name}-{environment}.svc.pinecone.io`.

  The connection test and `list_indexes` instead call the controller URL `https://controller.{environment}.pinecone.io/indexes`, while the saved-credential test uses `https://api.pinecone.io/indexes`.
</Expandable>

<Warning>
  The environment-derived host (`https://{index_name}-{environment}.svc.pinecone.io`) and the controller host (`https://controller.{environment}.pinecone.io`) follow Pinecone's **legacy pod-based** URL conventions. Pinecone **serverless** indexes use a different host. If your queries return connection errors or `404` despite a valid key, set `index_host` in `auth_data` to the exact host shown in your Pinecone console. {/* TODO: confirm the connect UI exposes index_host; today it is read by the adapter (pinecone_adapter.py:59-60) but not declared in the manifest fields. */}
</Warning>

### Normalized result

ModuleX maps each Pinecone match into a standard result object before formatting:

<ResponseField name="id" type="string">
  The Pinecone match id (the vector id).
</ResponseField>

<ResponseField name="score" type="number">
  Pinecone's raw similarity score for the match. Matches below `min_score` are dropped before this point.
</ResponseField>

<ResponseField name="content" type="string">
  Text extracted from the match metadata. ModuleX checks common metadata fields in order: `content`, `text`, `chunk_text`, `page_content`, `data`, `body`, `summary`, `document`. If none are present, `content` is empty — store your chunk text under one of these keys in Pinecone metadata so retrieved chunks carry usable text.
</ResponseField>

<ResponseField name="metadata" type="object">
  The match metadata, included when `include_metadata` is `true`.
</ResponseField>

<ResponseField name="vector" type="array">
  The stored vector values, included only when vector values are requested.
</ResponseField>

These results are then shaped into `chunks`, `context`, or `both` per the node's `output_format`.

## Billing

BYOK retrieval through Pinecone is **not metered in ModuleX credits**. Only knowledge bases whose embedding provider is managed (`modulexdb` / `modulexai`) reserve retrieval credits. Two cost notes still apply:

* **Pinecone bills you directly** for queries and storage on your own account.
* **The query embedding may be metered.** If your `embedding_config` uses a managed embedding model, generating the query vector is billed in ModuleX credits like any other managed model call. Using a BYOK embedding credential avoids that. See [credits & metering](/billing/credits).

## Errors and edge cases

<AccordionGroup>
  <Accordion title="Invalid Pinecone API key">
    A bad or revoked key returns `401` from Pinecone. ModuleX surfaces this as an authentication error (`"Invalid Pinecone API key"`). Re-test the credential with `POST /credentials/{credential_id}/test` and rotate the key in Pinecone if needed.
  </Accordion>

  <Accordion title="Index not found (404)">
    If Pinecone returns `404` for the query, ModuleX raises `"Index not found: <index_name>"`. Verify the `collection_name` matches an index in your project, and check the [Index URL resolution](#index-url-resolution) rules — a serverless index on the legacy host pattern is the usual cause. Set `index_host` to fix it.
  </Accordion>

  <Accordion title="Missing embedding_config">
    Pinecone requires a pre-computed query vector. Without `embedding_config`, the node raises `"embedding_config required for providers that don't handle embeddings…"` and never calls Pinecone. Add an `embedding_config` whose dimension matches your index.
  </Accordion>

  <Accordion title="Missing collection_name">
    The node raises `"collection_name is required for external provider: pinecone"`. Set `collection_name` to your index name.
  </Accordion>

  <Accordion title="Dimension mismatch or other query failure">
    Any other Pinecone error (for example a vector-dimension mismatch) surfaces as a `500` with `"Pinecone query failed: <pinecone message>"`. Confirm your embedding model dimension equals the index dimension.
  </Accordion>

  <Accordion title="Empty content in results">
    Pinecone returns vector ids, scores, and metadata — not separate text. If retrieved chunks have empty `content`, store the chunk text in metadata under one of the recognized keys (`content`, `text`, `chunk_text`, `page_content`, `data`, `body`, `summary`, `document`).
  </Accordion>
</AccordionGroup>

## Provider actions reference

Beyond workflow retrieval, the Pinecone integration declares three catalog actions, surfaced through the knowledge-provider catalog and the [tool node](/workflow-builder/nodes/tool). Authentication is the same `custom` API-key schema described above.

<AccordionGroup>
  <Accordion title="query — vector similarity search">
    Performs a vector similarity search on a Pinecone index.

    **Parameters**

    <ParamField path="index_name" type="string" required>
      Name of the Pinecone index to search.
    </ParamField>

    <ParamField path="namespace" type="string">
      Namespace within the index.
    </ParamField>

    <ParamField path="query_vector" type="array" required>
      Query embedding vector.
    </ParamField>

    <ParamField path="top_k" type="integer" default="5">
      Number of results to return.
    </ParamField>

    <ParamField path="filter" type="object">
      Metadata filter conditions.
    </ParamField>

    <ParamField path="include_metadata" type="boolean" default="true">
      Include metadata in results.
    </ParamField>

    <ParamField path="include_values" type="boolean" default="false">
      Include vector values in results.
    </ParamField>

    **Output**

    <ResponseField name="matches" type="array">
      Array of matches, each with `id`, `score`, `metadata`, and `values`.
    </ResponseField>

    <ResponseField name="namespace" type="string">
      The namespace searched.
    </ResponseField>
  </Accordion>

  <Accordion title="list_indexes — list project indexes">
    Lists all indexes in your Pinecone project. Takes no parameters.

    **Output:** an array of indexes, each with `name`, `dimension`, `metric`, and `status`.
  </Accordion>

  <Accordion title="describe_index — index statistics">
    Returns statistics about one index.

    **Parameters**

    <ParamField path="index_name" type="string" required>
      Name of the index.
    </ParamField>

    **Output**

    <ResponseField name="dimension" type="integer">
      The index vector dimension.
    </ResponseField>

    <ResponseField name="total_vector_count" type="integer">
      Total vectors in the index.
    </ResponseField>

    <ResponseField name="namespaces" type="object">
      Per-namespace vector counts.
    </ResponseField>
  </Accordion>
</AccordionGroup>

## Related pages

<CardGroup cols={2}>
  <Card title="Knowledge providers overview" icon="database" href="/integrations/knowledge-providers/overview">
    Compare managed and BYOK vector stores and see all supported providers.
  </Card>

  <Card title="Knowledge node" icon="diagram-project" href="/workflow-builder/nodes/knowledge">
    Configure retrieval inside a workflow.
  </Card>

  <Card title="Managing credentials" icon="key" href="/integrations/managing-credentials">
    Create, rotate, and scope credentials in the app and via API.
  </Card>

  <Card title="Knowledge & RAG" icon="book-open" href="/concepts/knowledge-rag">
    How ModuleX retrieves company knowledge end to end.
  </Card>
</CardGroup>