Your First Trace

import 'dotenv/config';
import { init, traceLLM, traceRetrieval, traceChain } from '@thinkhive/sdk';
import OpenAI from 'openai';
 
// Initialize ThinkHive
init({
  serviceName: 'rag-demo',
  debug: true,  // Enable debug logging
});
 
const openai = new OpenAI();

import os
from dotenv import load_dotenv
import thinkhive
from openai import OpenAI
 
load_dotenv()
 
# Initialize ThinkHive
thinkhive.init(
    service_name="rag-demo",
)
 
client = OpenAI()

// Simple in-memory knowledge base
const knowledgeBase = [
  {
    id: 'doc1',
    content: 'ThinkHive is an AI observability platform that helps teams monitor and improve their AI agents.',
    embedding: [0.1, 0.2, 0.3], // Simplified for demo
  },
  {
    id: 'doc2',
    content: 'ThinkHive supports RAG evaluation, hallucination detection, and drift monitoring.',
    embedding: [0.2, 0.3, 0.4],
  },
  {
    id: 'doc3',
    content: 'ThinkHive integrates with OpenAI, LangChain, and supports OpenTelemetry for tracing.',
    embedding: [0.3, 0.4, 0.5],
  },
];
 
// Simple similarity search (in production, use a vector database)
function simpleSearch(query, topK = 2) {
  // Return top K documents (simplified - no actual embedding comparison)
  return knowledgeBase.slice(0, topK);
}

# Simple in-memory knowledge base
knowledge_base = [
    {
        "id": "doc1",
        "content": "ThinkHive is an AI observability platform that helps teams monitor and improve their AI agents.",
    },
    {
        "id": "doc2",
        "content": "ThinkHive supports RAG evaluation, hallucination detection, and drift monitoring.",
    },
    {
        "id": "doc3",
        "content": "ThinkHive integrates with OpenAI, LangChain, and supports OpenTelemetry for tracing.",
    },
]
 
# Simple similarity search (in production, use a vector database)
def simple_search(query: str, top_k: int = 2) -> list:
    return knowledge_base[:top_k]

async function searchDocuments(query) {
  // Wrap retrieval in a traced span
  const documents = await traceRetrieval({
    name: 'knowledge-search',
    query: query,
    topK: 2,
  }, async () => {
    const results = simpleSearch(query, 2);
    return results;
  });
 
  return documents;
}

@thinkhive.trace_retrieval(query="knowledge search")
def search_documents(query: str) -> list:
    """Search knowledge base with tracing."""
    results = simple_search(query, top_k=2)
    return results

async function generateResponse(query, context) {
  const response = await traceLLM({
    name: 'answer-generation',
    modelName: 'gpt-4',
    provider: 'openai',
    input: query,
  }, async () => {
    const completion = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'system',
          content: `You are a helpful assistant. Answer based on this context:\n\n${context}`,
        },
        {
          role: 'user',
          content: query,
        },
      ],
      temperature: 0.7,
    });
    return completion;
  });
 
  return response.choices[0].message.content;
}

@thinkhive.trace_llm(model_name="gpt-4", provider="openai")
def generate_response(query: str, context: str) -> str:
    """Generate response with tracing."""
    completion = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system",
                "content": f"You are a helpful assistant. Answer based on this context:\n\n{context}",
            },
            {"role": "user", "content": query},
        ],
        temperature=0.7,
    )
    return completion.choices[0].message.content

async function ragChat(userQuestion) {
  // Wrap entire pipeline in a chain trace
  const answer = await traceChain({
    name: 'rag-pipeline',
    input: { question: userQuestion },
  }, async () => {
    // Step 1: Retrieve relevant documents
    const documents = await searchDocuments(userQuestion);
 
    // Step 2: Build context from documents
    const context = documents.map(d => d.content).join('\n\n');
 
    // Step 3: Generate response
    const response = await generateResponse(userQuestion, context);
 
    return response;
  });
 
  return answer;
}
 
// Main execution
async function main() {
  console.log('Starting RAG Demo...\n');
 
  const questions = [
    'What is ThinkHive?',
    'What features does ThinkHive support?',
    'How does ThinkHive integrate with other tools?',
  ];
 
  for (const question of questions) {
    console.log(`Question: ${question}`);
    const answer = await ragChat(question);
    console.log(`Answer: ${answer}\n`);
  }
 
  console.log('Check your traces at https://app.thinkhive.ai/traces');
}
 
main().catch(console.error);

def rag_chat(user_question: str) -> str:
    """Complete RAG pipeline."""
    # Step 1: Retrieve relevant documents
    documents = search_documents(user_question)
 
    # Step 2: Build context from documents
    context = "\n\n".join(doc["content"] for doc in documents)
 
    # Step 3: Generate response
    response = generate_response(user_question, context)
 
    return response
 
 
if __name__ == "__main__":
    print("Starting RAG Demo...\n")
 
    questions = [
        "What is ThinkHive?",
        "What features does ThinkHive support?",
        "How does ThinkHive integrate with other tools?",
    ]
 
    for question in questions:
        print(f"Question: {question}")
        answer = rag_chat(question)
        print(f"Answer: {answer}\n")
 
    print("Check your traces at https://app.thinkhive.ai/traces")

node index.js

python main.py