Skip to main content
Pinecone Docs

Search documentation

Type to search this documentation.

On this pageOverview

Create an index with integrated embedding

With this type of index, you provide source text, and Pinecone uses a hosted embedding model to convert the text automatically during upsert and search.

For guidance and examples, see Create an index.

Python
# pip install --upgrade pinecone
from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

index_name = "integrated-dense-py"

index_model = pc.create_index_for_model(
    name=index_name,
    cloud="aws",
    region="us-east-1",
    embed={
        "model":"llama-text-embed-v2",
        "field_map":{"text": "chunk_text"}
    }
)

# Import specific classes to get type hints and autocompletions
from pinecone import CloudProvider, AwsRegion, IndexEmbed, EmbedModel

index_model = pc.create_index_for_model(
    name=index_name,
    cloud=CloudProvider.AWS,
    region=AwsRegion.US_EAST_1,
    embed=IndexEmbed(
        model=EmbedModel.Multilingual_E5_Large,
        field_map={"text": "chunk_text"},
        metric='cosine'
    )
)
JavaScript
// npm install @pinecone-database/pinecone
import { Pinecone } from '@pinecone-database/pinecone'

const pc = new Pinecone({ apiKey: 'YOUR_API_KEY' });

await pc.createIndexForModel({
  name: 'integrated-dense-js',
  cloud: 'aws',
  region: 'us-east-1',
  embed: {
    model: 'llama-text-embed-v2',
    fieldMap: { text: 'chunk_text' },
  },
  waitUntilReady: true,
});
Java
import io.pinecone.clients.Pinecone;
import org.openapitools.db_control.client.ApiException;
import org.openapitools.db_control.client.model.CreateIndexForModelRequest;
import org.openapitools.db_control.client.model.CreateIndexForModelRequestEmbed;
import org.openapitools.db_control.client.model.DeletionProtection;
import org.openapitools.db_control.client.model.IndexModel;

import java.util.HashMap;
import java.util.Map;

public class CreateIntegratedIndex {
    public static void main(String[] args) throws ApiException {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        String indexName = "integrated-dense-java";
        String region = "us-east-1";
        HashMap<String, String> fieldMap = new HashMap<>();
        fieldMap.put("text", "chunk_text");
        CreateIndexForModelRequestEmbed embed = new CreateIndexForModelRequestEmbed()
                .model("llama-text-embed-v2")
                .fieldMap(fieldMap);
        Map<String, String> tags = new HashMap<>();
        tags.put("environment", "development");
        IndexModel index = pc.createIndexForModel(
                indexName,
                CreateIndexForModelRequest.CloudEnum.AWS,
                region,
                embed,
                DeletionProtection.DISABLED,
                tags
        );
        System.out.println(index);
    }
}
Go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v4/pinecone"
)

func main() {
    ctx := context.Background()

    pc, err := pinecone.NewClient(pinecone.NewClientParams{
        ApiKey: "YOUR_API_KEY",
    })
    if err != nil {
        log.Fatalf("Failed to create Client: %v", err)
    }

  	indexName := "integrated-dense-go"
    DeletionProtection: &deletionProtection,

    index, err := pc.CreateIndexForModel(ctx, &pinecone.CreateIndexForModelRequest{
		Name:   indexName,
		Cloud:  pinecone.Aws,
		Region: "us-east-1",
		Embed: pinecone.CreateIndexForModelEmbed{
			Model:    "llama-text-embed-v2",
			FieldMap: map[string]interface{}{"text": "chunk_text"},
		},
    DeletionProtection: &deletionProtection,
    Tags:   &pinecone.IndexTags{ "environment": "development" },
	})
    if err != nil {
        log.Fatalf("Failed to create serverless integrated index: %v", idx.Name)
    } else {
        fmt.Printf("Successfully created serverless integrated index: %v", idx.Name)
    }
}
C#
using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

var createIndexRequest = await pinecone.CreateIndexForModelAsync(
    new CreateIndexForModelRequest
    {
        Name = "integrated-dense-dotnet",
        Cloud = CreateIndexForModelRequestCloud.Aws,
        Region = "us-east-1",
        Embed = new CreateIndexForModelRequestEmbed
        {
            Model = "llama-text-embed-v2",
            FieldMap = new Dictionary<string, object?>() { { "text", "chunk_text" } },
        },
        DeletionProtection = DeletionProtection.Disabled,
        Tags = new Dictionary<string, string> 
        { 
            { "environment", "development" }
        }
    }
);
curl
PINECONE_API_KEY="YOUR_API_KEY"

curl -X POST https://api.pinecone.io/indexes/create-for-model \
     -H "Content-Type: application/json" \
     -H "Api-Key: $PINECONE_API_KEY" \
     -H "X-Pinecone-Api-Version: 2025-04" \
     -d '{
           "name": "integrated-dense-curl",
           "cloud": "aws",
           "region": "us-east-1",
           "embed": {
             "model": "llama-text-embed-v2",
             "metric": "cosine",
             "field_map": {
               "text": "chunk_text"
             },
             "write_parameters": {
               "input_type": "passage",
               "truncate": "END"
             },
             "read_parameters": {
               "input_type": "query",
               "truncate": "END"
             }
           }
         }'
CLI
# Target the project where you want to create the index.
pc target -o "example-org" -p "example-project"
# Create the index.
pc index create \
  --name "integrated-dense-cli" \
  --dimension 1024 \
  --metric "cosine" \
  --cloud "aws" \
  --region "us-east-1" \
  --model "llama-text-embed-v2" \
  --field_map "text=chunk_text"
Python
{'deletion_protection': 'disabled',
 'dimension': 1024,
 'embed': {'dimension': 1024,
           'field_map': {'text': 'chunk_text'},
           'metric': 'cosine',
           'model': 'llama-text-embed-v2',
           'read_parameters': {'input_type': 'query', 'truncate': 'END'},
           'write_parameters': {'input_type': 'passage', 'truncate': 'END'}},
 'host': 'integrated-dense-py-govk0nt.svc.aped-4627-b74a.pinecone.io',
 'id': '9dabb7cb-ec0a-4e2e-b79e-c7c997e592ce',
 'metric': 'cosine',
 'name': 'integrated-dense-py',
 'spec': {'serverless': {'cloud': 'aws', 'region': 'us-east-1'}},
 'status': {'ready': True, 'state': 'Ready'},
 'tags': None}
JavaScript
{
  "name": "integrated-dense-js",
  "dimension": 1024,
  "metric": "cosine",
  "host": "integrated-dense-js-govk0nt.svc.aped-4627-b74a.pinecone.io",
  "deletionProtection": "disabled",
  "tags": undefined,
  "embed": {
    "model": "llama-text-embed-v2",
    metric: 'cosine',
    dimension: 1024,
    vectorType: 'dense',
    fieldMap: { text: 'chunk_text' },
    readParameters: { input_type: 'query', truncate: 'END' },
    writeParameters: { input_type: 'passage', truncate: 'END' }
  },
  spec: { pod: undefined, serverless: { cloud: 'aws', region: 'us-east-1' } },
  status: { ready: true, state: 'Ready' },
  vectorType: 'dense'
}
Java
class IndexModel {
    name: integrated-dense-java
    dimension: 1024
    metric: cosine
    host: integrated-dense-java-govk0nt.svc.aped-4627-b74a.pinecone.io
    deletionProtection: disabled
    tags: {environment=development}
    embed: class ModelIndexEmbed {
        model: llama-text-embed-v2
        metric: cosine
        dimension: 1024
        vectorType: dense
        fieldMap: {text=chunk_text}
        readParameters: {dimension=1024.0, input_type=query, truncate=END}
        writeParameters: {dimension=1024.0, input_type=passage, truncate=END}
        additionalProperties: null
    }
    spec: class IndexModelSpec {
        byoc: null
        pod: null
        serverless: class ServerlessSpec {
            cloud: aws
            region: us-east-1
            additionalProperties: null
        }
        additionalProperties: null
    }
    status: class IndexModelStatus {
        ready: false
        state: Initializing
        additionalProperties: null
    }
    vectorType: dense
    additionalProperties: null
}
Go
{
  "name": "integrated-dense-go",
  "host": "integrated-dense-go-govk0nt.svc.aped-4627-b74a.pinecone.io",
  "metric": "cosine",
  "vector_type": "dense",
  "deletion_protection": "disabled",
  "dimension": 1024,
  "spec": {
    "serverless": {
      "cloud": "aws",
      "region": "us-east-1"
    }
  },
  "status": {
    "ready": true,
    "state": "Ready"
  },
  "embed": {
    "model": "llama-text-embed-v2",
    "dimension": 1024,
    "metric": "cosine",
    "vector_type": "dense",
    "field_map": {
      "text": "chunk_text"
    },
    "read_parameters": {
      "input_type": "query",
      "truncate": "END"
    },
    "write_parameters": {
      "input_type": "passage",
      "truncate": "END"
    }
  }
}
C#
{
  "name": "integrated-dense-dotnet",
  "dimension": 1024,
  "metric": "cosine",
  "host": "integrated-dense-dotnet-govk0nt.svc.aped-4627-b74a.pinecone.io",
  "deletion_protection": "disabled",
  "tags": {
    "environment": "development"
  },
  "embed": {
    "model": "llama-text-embed-v2",
    "metric": "cosine",
    "dimension": 1024,
    "vector_type": "dense",
    "field_map": {
      "text": "chunk_text"
    },
    "read_parameters": {
      "dimension": 1024,
      "input_type": "query",
      "truncate": "END"
    },
    "write_parameters": {
      "dimension": 1024,
      "input_type": "passage",
      "truncate": "END"
    }
  },
  "spec": {
    "serverless": {
      "cloud": "aws",
      "region": "us-east-1"
    }
  },
  "status": {
    "ready": true,
    "state": "Ready"
  },
  "vector_type": "dense"
}
curl
{
  "id": "9dabb7cb-ec0a-4e2e-b79e-c7c997e592ce",
  "name": "integrated-dense-curl",
  "metric": "cosine",
  "dimension": 1024,
  "status": {
    "ready": false,
    "state": "Initializing"
  },
  "host": "integrated-dense-curl-govk0nt.svc.aped-4627-b74a.pinecone.io",
  "spec": {
    "serverless": {
      "region": "us-east-1",
      "cloud": "aws"
    }
  },
  "deletion_protection": "disabled",
  "tags": null,
  "embed": {
    "model": "llama-text-embed-v2",
    "field_map": {
      "text": "chunk_text"
    },
    "dimension": 1024,
    "metric": "cosine",
    "write_parameters": {
      "input_type": "passage",
      "truncate": "END"
    },
    "read_parameters": {
      "input_type": "query",
      "truncate": "END"
    }
  }
}
CLI
[SUCCESS] Index integrated-dense-cli created successfully. Run pc index describe --name integrated-dense-cli to check status.


ATTRIBUTE              VALUE
Name                   integrated-dense-cli
Dimension              1024
Metric                 cosine
Deletion Protection    disabled
Vector Type            dense

State                  Initializing
Ready                  false
Host                   integrated-dense-cli-1c6ab6aa.svc.aped-4627-b74a.pinecone.io
Private Host           <none>

Spec                   serverless
Cloud                  aws
Region                 us-east-1
Source Collection      <none>

Model                  llama-text-embed-v2
Field Map              {"text":"chunk_text"}
Read Parameters        {"dimension":1024,"input_type":"query","truncate":"END"}
Write Parameters       {"dimension":1024,"input_type":"passage","truncate":"END"}

POST /indexes/create-for-model

Request body

Section titled “Request body”
  • name (body, string, required) — The name of the index. Resource name must be 1-45 characters long, start and end with an alphanumeric character, and consist only of lower case alphanumeric characters or '-'.
  • cloud (body, string, required) — The public cloud where you would like your index hosted.
  • region (body, string, required) — The region where you would like your index to be created.
  • deletion_protection (body, string) — Whether deletion protection is enabled/disabled for the index.
  • tags (body, object) — Custom user tags added to an index. Keys must be 80 characters or less. Values must be 120 characters or less. Keys must be alphanumeric, '', or '-'. Values must be alphanumeric, ';', '@', '', '-', '.', '+', or ' '. To unset a key, set the value to be an empty string.
  • embed (body, object, required) — Specify the integrated inference embedding configuration for the index. Once set the model cannot be changed, but you can later update the embedding configuration for an integrated inference index including field map, read parameters, or write parameters. Refer to the model guide for available models and model details.

Responses

Section titled “Responses”
  • 201 — The index has successfully been created for the embedding model.
  • 400 — Bad request. The request body included invalid request parameters.
  • 401 — Unauthorized. Possible causes: Invalid API key.
  • 404 — Unknown cloud or region when creating a serverless index.
  • 409 — Index of given name already exists.
  • 422 — Unprocessable entity. The request body could not be deserialized.
  • 500 — Internal server error.
Suggest an edit

Propose a replacement for this page. The site team reviews it before applying any changes.

Export
Documentation menu