import ai.traceai.TraceAI;
import ai.traceai.TraceConfig;
import ai.traceai.openai.TracedOpenAIClient;

// Initialize TraceAI
TraceAI.init(TraceConfig.builder()
    .baseUrl("https://api.futureagi.com")
    .apiKey(System.getenv("TRACEAI_API_KEY"))
    .projectName("my-java-app")
    .build());

// Create traced client
OpenAIClient openai = OpenAIOkHttpClient.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .build();
TracedOpenAIClient traced = new TracedOpenAIClient(openai);

// All calls are now traced!
ChatCompletion response = traced.createChatCompletion(
    ChatCompletionCreateParams.builder()
        .model("gpt-4")
        .addMessage(ChatCompletionMessageParam.user("Hello!"))
        .build()
);

import ai.traceai.langchain4j.TracedChatLanguageModel;
import ai.traceai.langchain4j.TracedAiServices;

// Wrap a ChatLanguageModel
ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey("...")
    .modelName("gpt-4")
    .build();

ChatLanguageModel traced = new TracedChatLanguageModel(model, "openai");

// Or wrap an AiService
interface Assistant {
    String chat(String message);
}

Assistant assistant = TracedAiServices.create(
    Assistant.class,
    AiServices.builder(Assistant.class)
        .chatLanguageModel(model)
        .build()
);

import ai.traceai.cohere.TracedCohereClient;

CohereClient cohere = CohereClient.builder()
    .apiKey(System.getenv("COHERE_API_KEY"))
    .build();
TracedCohereClient traced = new TracedCohereClient(cohere);

// Chat
ChatResponse chat = traced.chat(ChatRequest.builder()
    .message("What is AI?")
    .build());

// Embeddings
EmbedResponse embed = traced.embed(EmbedRequest.builder()
    .texts(List.of("Hello world"))
    .model("embed-english-v3.0")
    .build());

// Rerank
RerankResponse rerank = traced.rerank(RerankRequest.builder()
    .query("What is AI?")
    .documents(List.of("AI is...", "Machine learning..."))
    .model("rerank-english-v3.0")
    .build());

import ai.traceai.ollama.TracedOllamaAPI;

OllamaAPI ollama = new OllamaAPI("http://localhost:11434");
TracedOllamaAPI traced = new TracedOllamaAPI(ollama);

// Generate
OllamaResult result = traced.generate("llama2", "What is AI?", null);

// Embeddings
List<double[]> embeddings = traced.embed("llama2", List.of("Hello world"));

import ai.traceai.azure.openai.TracedAzureOpenAIClient;
import com.azure.ai.openai.OpenAIClientBuilder;

// Create Azure OpenAI client
OpenAIClient client = new OpenAIClientBuilder()
    .endpoint(System.getenv("AZURE_OPENAI_ENDPOINT"))
    .credential(new AzureKeyCredential(System.getenv("AZURE_OPENAI_API_KEY")))
    .buildClient();

TracedAzureOpenAIClient traced = new TracedAzureOpenAIClient(client);

// Chat completions
ChatCompletions response = traced.getChatCompletions("gpt-4-deployment",
    new ChatCompletionsOptions(List.of(
        new ChatRequestUserMessage("What is machine learning?")
    )));

// Embeddings
Embeddings embeddings = traced.getEmbeddings("text-embedding-ada-002",
    new EmbeddingsOptions(List.of("Hello world")));

import ai.traceai.watsonx.TracedWatsonxAI;

// Create watsonx client (using reflection-based API)
Object watsonxClient = createWatsonxClient();
TracedWatsonxAI traced = new TracedWatsonxAI(watsonxClient);

// Text generation
Object response = traced.generateText(textGenRequest);

// Chat
Object chatResponse = traced.chat(chatRequest);

// Embeddings
Object embeddings = traced.embedText(embedRequest);

import ai.traceai.semantickernel.*;
import com.microsoft.semantickernel.Kernel;

// Create Semantic Kernel
Kernel kernel = Kernel.builder()
    .withAIService(ChatCompletionService.class, chatService)
    .build();

// Wrap with tracing
TracedKernel tracedKernel = new TracedKernel(kernel);

// Invoke functions with tracing
FunctionResult<String> result = tracedKernel.invokeAsync(myFunction, arguments).block();

// Or use TracedChatCompletionService directly
TracedChatCompletionService tracedChat = new TracedChatCompletionService(
    chatService, "gpt-4", "openai");

List<ChatMessageContent> response = tracedChat.getChatMessageContentsAsync(
    chatHistory, kernel, null).block();

// Embeddings with tracing
TracedTextEmbeddingGenerationService tracedEmbedding =
    new TracedTextEmbeddingGenerationService(embeddingService, "text-embedding-ada-002");

List<Embedding> embeddings = tracedEmbedding.generateEmbeddingsAsync(
    List.of("Hello world")).block();

// Pinecone
import ai.traceai.pinecone.TracedPineconeIndex;

Pinecone pinecone = new Pinecone.Builder().apiKey("...").build();
Index index = pinecone.getIndexConnection("my-index");
TracedPineconeIndex traced = new TracedPineconeIndex(index, "my-index");

QueryResponse results = traced.query(queryVector, 10, null, true, true);

// Qdrant
import ai.traceai.qdrant.TracedQdrantClient;

QdrantClient qdrant = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
TracedQdrantClient traced = new TracedQdrantClient(qdrant);

List<ScoredPoint> results = traced.search("my_collection", queryVector, 10, null, null);

// ChromaDB
import ai.traceai.chromadb.TracedChromaCollection;

Client client = new Client("http://localhost:8000");
Collection collection = client.getOrCreateCollection("my_collection", null, null, null);
TracedChromaCollection traced = new TracedChromaCollection(collection, "my_collection");

Collection.QueryResponse results = traced.query(queryEmbeddings, 10, null, null, null);

// Elasticsearch
import ai.traceai.elasticsearch.TracedElasticsearchClient;

ElasticsearchClient esClient = new ElasticsearchClient(transport);
TracedElasticsearchClient traced = new TracedElasticsearchClient(esClient);

// k-NN vector search
SearchResponse<Map<String, Object>> results = traced.knnSearch(
    "my-index", queryVector, 10, 100, "embedding");

// Index documents with vectors
traced.index("my-index", "doc-1", Map.of(
    "title", "Hello World",
    "embedding", vectorData
));

// PostgreSQL pgvector
import ai.traceai.pgvector.TracedPgVectorStore;

DataSource dataSource = createDataSource();
TracedPgVectorStore store = new TracedPgVectorStore(dataSource);

// Create table and index
store.createTable("documents", 1536);
store.createIndex("documents", "HNSW", 16);

// Insert vectors
store.insert("documents", "doc-1", embedding, Map.of("title", "Hello"));

// Similarity search
List<SearchResult> results = store.search("documents", queryVector, 10, "cosine");

// Azure AI Search
import ai.traceai.azure.search.TracedSearchClient;

SearchClient searchClient = new SearchClientBuilder()
    .endpoint(endpoint)
    .indexName("my-index")
    .credential(new AzureKeyCredential(apiKey))
    .buildClient();

TracedSearchClient traced = new TracedSearchClient(searchClient, "my-index");

// Vector search
SearchPagedIterable results = traced.searchWithVector(null, vectorData, "embedding", 10);

// Hybrid search (text + vector)
SearchPagedIterable hybridResults = traced.hybridSearch("machine learning", vectorData, "embedding", 10);

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

TraceConfig config = TraceConfig.builder()
    .baseUrl("https://api.futureagi.com")
    .apiKey("your-api-key")
    .projectName("my-project")
    .serviceName("my-service")
    .hideInputs(false)        // Set to true to hide input values
    .hideOutputs(false)       // Set to true to hide output values
    .enableConsoleExporter(false)  // Set to true for local debugging
    .batchSize(512)           // Span batch size
    .exportIntervalMs(5000)   // Export interval in ms
    .build();

TraceAI.init(config);