Pinecone

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

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());