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

# Pinecone

> Learn how to integrate Pinecone with HoneyHive for vector database monitoring, tracing, and retrieval evaluations.

export const integrationType_1 = "Pinecone"

export const integrationType_0 = "Pinecone"

Pinecone is a vector database service that is designed to enable developers to work with high-dimensional vector data efficiently.

With HoneyHive, you can trace all your {integrationType_0} operations using a single line of code. Find a list of all supported integrations [here](/introduction/troubleshooting#latest-package-versions-tested).

## HoneyHive Setup

Follow the [HoneyHive Installation Guide](/integrations/integration-prereqs) to get your API key and initialize the tracer.

## Pinecone Setup

Log in to the [Pinecone Console](https://app.pinecone.io/) to create a new project and get your API key.

Note: please use version `pinecone-client==5.0.0` for Python.

## Example

Here is an example of how to trace your {integrationType_1} code in HoneyHive.

<CodeGroup>
  ```python Python theme={null}
  from openai import OpenAI
  from pinecone import Pinecone

  from honeyhive.tracer import HoneyHiveTracer
  from honeyhive.tracer.custom import trace

  # Initialize HoneyHive Tracer
  HoneyHiveTracer.init(
      api_key="MY_HONEYHIVE_API_KEY",
      project="MY_HONEYHIVE_PROJECT_NAME",
      session_name="pinecone-docs"
  )

  # Initialize clients
  openai_client = OpenAI()
  pc = Pinecone(api_key="MY_PINECONE_API_KEY")
  index = pc.Index("MY_PINECONE_INDEX_NAME")

  def embed_query(query):
      res = openai_client.embeddings.create(
          model="text-embedding-ada-002",
          input=query
      )
      query_vector = res.data[0].embedding
      return query_vector

  documents = [
      "Jack is a software engineer.",
      "Jill is a nurse.",
      "Jane is a teacher.",
      "John is a doctor.",
  ]

  index.upsert(vectors=[
      {
          "id": "A", "values": embed_query(documents[0]), "metadata": {"_node_content": documents[0]}
      },
      {
          "id": "B", "values": embed_query(documents[1]), "metadata": {"_node_content": documents[1]}
      }
  ])

  @trace(
      config={
          "embedding_model": "text-embedding-ada-002",
          "top_k": 3
      }
  )
  def get_relevant_documents(query):
      query_vector = embed_query(query)
      res = index.query(vector=query_vector, top_k=3, include_metadata=True)
      print(res)
      return [item['metadata']['_node_content'] for item in res['matches']]

  @trace(
      config={
          "model": "gpt-4o",
          "prompt": "You are a helpful assistant" 
      },
      metadata={
          "version": 1
      }
  )
  def generate_response(context, query):
      prompt = f"Context: {context}\n\nQuestion: {query}\n\nAnswer:"
      response = openai_client.chat.completions.create(
          model="gpt-4o",
          messages=[
              {"role": "system", "content": "You are a helpful assistant."},
              {"role": "user", "content": prompt}
          ]
      )
      return response.choices[0].message.content

  @trace()
  def rag_pipeline(query):
      docs = get_relevant_documents(query)
      response = generate_response("\n".join(docs), query)
      return response

  def main():
      query = "What does Jack do?"
      response = rag_pipeline(query)
      print(f"Query: {query}")
      print(f"Response: {response}")

  if __name__ == "__main__":
      main()
  ```

  ```typescript TypeScript theme={null}

  import { OpenAI } from 'openai';
  import { Pinecone } from '@pinecone-database/pinecone';
  import { HoneyHiveTracer } from "honeyhive";

  interface TracerConfig {
      apiKey: string;
      project: string;
      sessionName: string;
  }

  interface RelevantDocsConfig {
      embedding_model: string;
      top_k: number;
  }

  interface GenerateResponseConfig {
      model: string;
      prompt: string;
  }

  interface PineconeMetadata {
      _node_content: string;
  }

  interface PineconeMatch {
      metadata: PineconeMetadata;
  }

  interface PineconeQueryResponse {
      matches: PineconeMatch[];
  }

  // Initialize the HoneyHive tracer at the start
  const tracer = await HoneyHiveTracer.init({
      apiKey: "MY_HONEYHIVE_API_KEY",
      project: "MY_HONEYHIVE_PROJECT_NAME",
      sessionName: "pinecone",
  } as TracerConfig);

  // Initialize clients
  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
  const pc = new Pinecone({ apiKey: "MY_PINECONE_API_KEY" });
  const index = pc.index("MY_PINECONE_INDEX_NAME");

  const documents: string[] = [
      "Jack is a software engineer.",
      "Jill is a nurse.",
      "Jane is a teacher.",
      "John is a doctor.",
  ];

  const embedQuery = async (query: string): Promise<number[]> => {
      const embeddingResponse = await openai.embeddings.create({
          model: "text-embedding-ada-002",
          input: query
      });
      return embeddingResponse.data[0].embedding;
  };

  const getRelevantDocumentsConfig: RelevantDocsConfig = {
      "embedding_model": "text-embedding-ada-002",
      "top_k": 3
  };

  await index.upsert([
      {
          "id": "A",
          "values": await embedQuery(documents[0]),
          "metadata": { "_node_content": documents[0] }
      },
      {
          "id": "B",
          "values": await embedQuery(documents[1]),
          "metadata": { "_node_content": documents[1] }
      }
  ]);

  const getRelevantDocuments = tracer.traceFunction(getRelevantDocumentsConfig)(
      async function getRelevantDocuments(queryVector: number[]): Promise<string[]> {
          const queryResult = await index.query({
              vector: queryVector,
              topK: 3,
              includeMetadata: true
          }) as PineconeQueryResponse;
          
          return queryResult.matches.map(item => item.metadata._node_content);
      }
  );

  const generateResponseConfig: GenerateResponseConfig = {
      "model": "gpt-4o",
      "prompt": "You are a helpful assistant" 
  };
  const generateResponseMetadata = {
      "version": 1
  };

  const generateResponse = tracer.traceFunction(generateResponseConfig, generateResponseMetadata)(
      async function generateResponse(context: string, query: string): Promise<string> {
          const prompt = `Context: ${context}\n\nQuestion: ${query}\n\nAnswer:`;
          const completion = await openai.chat.completions.create({
              model: "gpt-4o",
              messages: [
                  { role: "system", content: "You are a helpful assistant." },
                  { role: "user", content: prompt }
              ]
          });
          return completion.choices[0].message.content || "";
      }
  );

  const ragPipeline = tracer.traceFunction()(
      async function ragPipeline(query: string): Promise<string> {
          const queryVector = await embedQuery(query);
          const relevantDocs = await getRelevantDocuments(queryVector);
          const context = relevantDocs.join("\n");
          const response = await generateResponse(context, query);
          
          return response;
      }
  );

  async function main(): Promise<void> {
      const query = "What does Jack do?";
      const response = await ragPipeline(query);

      console.log("Query", query);
      console.log("Response", response);
  }

  // Wrap execution entry with `tracer.trace`
  await tracer.trace(() => main());
  ```
</CodeGroup>

## View your Traces

Once you run your code, you can view your execution trace in the HoneyHive UI by clicking the `Log Store` tab on the left sidebar.