Create an index

# pip install "pinecone[grpc]"
# Serverless index
from pinecone.grpc import PineconeGRPC as Pinecone
from pinecone import ServerlessSpec

pc = Pinecone(api_key="YOUR_API_KEY")

pc.create_index(
    name="docs-example1",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(
        cloud="aws",
        region="us-east-1"
    ),
    deletion_protection="disabled",
    tags={
        "environment": "development"
    }
)

# Pod-based index
from pinecone.grpc import PineconeGRPC as Pinecone, PodSpec

pc = Pinecone(api_key="YOUR_API_KEY")

pc.create_index(
  name="docs-example2",
  dimension=1536,
  metric="cosine",
  spec=PodSpec(
    environment="us-west1-gcp",
    pod_type="p1.x1",
    pods=1,
  ),
  deletion_protection="disabled",
    tags={
        "environment": "development"
    }
)

// npm install @pinecone-database/pinecone
// Serverles index
import { Pinecone } from '@pinecone-database/pinecone'

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

await pc.createIndex({
  name: 'serverless-index',
  dimension: 1536,
  metric: 'cosine',
  spec: {
    serverless: {
      cloud: 'aws',
      region: 'us-east-1'
    }
  },
  deletionProtection: 'disabled',
  tags: { environment: 'development' }, 
});

// Pod-based index
await pc.createIndex({
  name: 'docs-example2',
  dimension: 1536,
  metric: 'cosine',
  spec: {
    pod: {
      environment: 'us-west1-gcp',
      podType: 'p1.x1',
      pods: 1
    }
  },
  deletionProtection: 'disabled',
  tags: { environment: 'development' }, 
});

import io.pinecone.clients.Pinecone;
import org.openapitools.db_control.client.model.DeletionProtection;
import java.util.HashMap;

// Serverless index
public class CreateServerlessIndexExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        HashMap<String, String> tags = new HashMap<>();
        tags.put("environment", "development");
        pc.createServerlessIndex("docs-example1", "cosine", 1536, "aws", 
                "us-east-1", DeletionProtection.DISABLED, tags);
    }
}

// Pod-based index
public class CreatePodIndexExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        HashMap<String, String> tags = new HashMap<>();
        tags.put("environment", "development");
        pc.createPodsIndex("docs-example2", 1536, "us-west1-gcp",
                "p1.x1", "cosine", DeletionProtection.DISABLED, tags);
    }
}

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v3/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)
    }

    // Serverless index
	indexName1 := "docs-example1"
	vectorType := "dense"
    dimension1 := int32(1536)
    metric1 := pinecone.Cosine
	deletionProtection1 := pinecone.DeletionProtectionDisabled

	idx1, err := pc.CreateServerlessIndex(ctx, &pinecone.CreateServerlessIndexRequest{
		Name:               indexName1,
		VectorType:         &vectorType,
        Dimension:          &dimension,
        Metric:             &metric,
		Cloud:              pinecone.Aws,
		Region:             "us-east-1",
		DeletionProtection: &deletionProtection,
	})
	if err != nil {
		log.Fatalf("Failed to create serverless index: %v", idx1.Name)
	} else {
		fmt.Printf("Successfully created serverless index: %v", idx1.Name)
	}

    // Pod-based index
    indexName2 := "docs-example2"
	metric2 := pinecone.Dotproduct
	deletionProtection2 := pinecone.DeletionProtectionDisabled

	idx2, err := pc.CreatePodIndex(ctx, &pinecone.CreatePodIndexRequest{
		Name:               indexName2,
		Metric:             &metric2,
		Dimension:          1536,
		Environment:        "us-east1-gcp",
		PodType:            "p1.x1",
		DeletionProtection: &deletionProtection2,
	})
  	if err != nil {
        log.Fatalf("Failed to create pod-based index: %v", idx2.Name)
    } else {
        fmt.Printf("Successfully created pod-based index: %v", idx2.Name)
    }
}

using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

// Serverless index
var createIndexRequest = await pinecone.CreateIndexAsync(new CreateIndexRequest
{
    Name = "docs-example1",
    Dimension = 1536,
    Metric = CreateIndexRequestMetric.Cosine,
    Spec = new ServerlessIndexSpec
    {
        Serverless = new ServerlessSpec
        {
            Cloud = ServerlessSpecCloud.Aws,
            Region = "us-east-1",
        }
    },
    DeletionProtection = DeletionProtection.Disabled,
    Tags = new Dictionary<string, string> 
    {  
        { "environment", "development" }
    }
});

// Pod-based index
var createIndexRequest = await pinecone.CreateIndexAsync(new CreateIndexRequest
{
    Name = "pod index",
    Dimension = 1536,
    Metric = CreateIndexRequestMetric.Cosine,
    Spec = new PodIndexSpec
    {
        Pod = new PodSpec
        {
            Environment = "us-east1-gcp",
            PodType = "p1.x1",
            Pods = 1,
        }
    },
    DeletionProtection = DeletionProtection.Disabled,
    Tags = new Dictionary<string, string> 
    {  
        { "environment", "development" }
    }
});

PINECONE_API_KEY="YOUR_API_KEY"

# Serverless index
curl -s "https://api.pinecone.io/indexes" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "X-Pinecone-Api-Version: 2025-01" \
  -d '{
        "name": "docs-example1",
        "dimension": 1536,
        "metric": "cosine",
        "spec": {
            "serverless": {
                "cloud": "aws",
                "region": "us-east-1"
            }
        },
        "tags": {
            "environment": "development"
        },
        "deletion_protection": "disabled"
      }'

# Pod-based index
curl -s "https://api.pinecone.io/indexes" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "X-Pinecone-Api-Version: 2025-01" \
  -d '{
         "name": "docs-example2",
         "dimension": 1536,
         "metric": "cosine",
         "spec": {
            "pod": {
               "environment": "us-west1-gcp",
               "pod_type": "p1.x1",
               "pods": 1
            }
         },
         "tags": {
            "environment": "development"
        },
         "deletion_protection": "disabled"
      }'

# Serverless index
{
    "name": "docs-example1",
    "metric": "cosine",
    "dimension": 1536,
    "status": {
        "ready": true,
        "state": "Ready"
    },
    "host": "docs-example1-4zo0ijk.svc.dev-us-west2-aws.pinecone.io",
    "spec": {
        "serverless": {
            "region": "us-east-1",
            "cloud": "aws"
        },
    "tags": {
            "environment": "development"
        }
    }
}

# Pod-based index
{
    "name": "docs-example2",
    "metric": "cosine",
    "dimension": 1536,
    "status": {
        "ready": true,
        "state": "Ready"
    },
    "host": "docs-example2-4zo0ijk.svc.us-west1-gcp.pinecone.io",
    "spec": {
        "pod": {
            "replicas": 1,
            "shards": 1,
            "pods": 1,
            "pod_type": "p1.x1",
            "environment": "us-west1-gcp"
        },
    "tags": {
        "environment": "development"
    }
    }
}