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"
)

# 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"
)

// 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: { example: 'tag', 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: { example: 'tag', environment: 'development' },
});

import io.pinecone.clients.Pinecone;

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

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

package main

import (
    "context"
    "fmt"
    "log"

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

    deletionProtection := pinecone.DeletionProtectionDisabled

    // Serverless index
    idx, err := pc.CreateServerlessIndex(ctx, &pinecone.CreateServerlessIndexRequest{
        Name:               "docs-example1",
        Dimension:          1536,
        Metric:             pinecone.Cosine,
        Cloud:              pinecone.Aws,
        Region:             "us-east-1",
        DeletionProtection: &deletionProtection,
        Tags:               &pinecone.IndexTags{ "example": "tag", "environment": "development" },
    })
  	if err != nil {
        log.Fatalf("Failed to create serverless index: %v", err)
    } else {
        fmt.Printf("Successfully created serverless index: %v", idx.Name)
    }

    // Pod-based index
    idx, err := pc.CreatePodIndex(ctx, &pinecone.CreatePodIndexRequest{
        Name:               "docs-example2",
        Dimension:          1536,
        Metric:             pinecone.Cosine,
        Environment:        "us-east1-gcp",
        PodType:            "p1.x1",
        DeletionProtection: &deletionProtection,
        Tags:               &pinecone.IndexTags{ "example": "tag", "environment": "development" },
    })
  	if err != nil {
        log.Fatalf("Failed to create pod-based index: %v", idx.Name)
    } else {
        fmt.Printf("Successfully created pod-based index: %v", idx.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
});

// 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
});

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: 2024-10" \
  -d '{
        "name": "docs-example1",
        "dimension": 1536,
        "metric": "cosine",
        "spec": {
        "serverless": {
            "cloud": "aws",
            "region": "us-east-1"
            }
        },
        "tags": {
            "example": "tag",
            "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: 2024-10" \
  -d '{
         "name": "docs-example2",
         "dimension": 1536,
         "metric": "cosine",
         "spec": {
            "pod": {
               "environment": "us-west1-gcp",
               "pod_type": "p1.x1",
               "pods": 1
            }
         },
         "tags": {
            "example": "tag",
            "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": {
            "example": "tag",
            "environment": "production"
        }
    }
}

# 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": {
        "example": "tag",
        "environment": "production"
    }
    }
}