pip install openai

import os
from openai import OpenAI

# Via variavel de ambiente (recomendado)
# export OPENAI_API_KEY="sua-api-key"

client = OpenAI()  # Automaticamente usa OPENAI_API_KEY

# Ou explicitamente
client = OpenAI(api_key="sua-api-key")

from openai import OpenAI

client = OpenAI()

def get_embedding(text: str, model: str = "text-embedding-3-small") -> list[float]:
    """Gera embedding para um texto"""
    response = client.embeddings.create(
        input=text,
        model=model
    )
    return response.data[0].embedding

# Exemplo
texto = "Machine learning e uma area fascinante da IA"
embedding = get_embedding(texto)

print(f"Texto: {texto}")
print(f"Dimensoes: {len(embedding)}")
print(f"Primeiros 5 valores: {embedding[:5]}")

def get_embeddings_batch(texts: list[str], model: str = "text-embedding-3-small") -> list[list[float]]:
    """Gera embeddings para multiplos textos de uma vez"""
    response = client.embeddings.create(
        input=texts,
        model=model
    )
    # Ordena pelo indice para manter a ordem original
    return [item.embedding for item in sorted(response.data, key=lambda x: x.index)]

# Exemplo
textos = [
    "Python e uma linguagem de programacao",
    "JavaScript roda no navegador",
    "Gatos sao animais domesticos"
]

embeddings = get_embeddings_batch(textos)
print(f"Gerados {len(embeddings)} embeddings")

import numpy as np

def cosine_similarity(vec1: list[float], vec2: list[float]) -> float:
    """Calcula similaridade do cosseno entre dois vetores"""
    vec1 = np.array(vec1)
    vec2 = np.array(vec2)
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# Comparando textos
texto1 = "Como treinar um modelo de machine learning?"
texto2 = "Qual e o processo para criar um modelo de ML?"
texto3 = "Qual e a receita de bolo de chocolate?"

emb1 = get_embedding(texto1)
emb2 = get_embedding(texto2)
emb3 = get_embedding(texto3)

print(f"Similaridade texto1-texto2: {cosine_similarity(emb1, emb2):.4f}")  # ~0.90
print(f"Similaridade texto1-texto3: {cosine_similarity(emb1, emb3):.4f}")  # ~0.40

from openai import OpenAI
import numpy as np

client = OpenAI()

class SemanticSearch:
    def __init__(self, model: str = "text-embedding-3-small"):
        self.model = model
        self.documents = []
        self.embeddings = []

    def add_documents(self, docs: list[str]):
        """Adiciona documentos ao indice"""
        self.documents.extend(docs)

        # Gera embeddings em batch
        response = client.embeddings.create(input=docs, model=self.model)
        new_embeddings = [item.embedding for item in sorted(response.data, key=lambda x: x.index)]
        self.embeddings.extend(new_embeddings)

    def search(self, query: str, top_k: int = 3) -> list[tuple[str, float]]:
        """Busca os documentos mais similares a query"""
        # Gera embedding da query
        response = client.embeddings.create(input=query, model=self.model)
        query_embedding = response.data[0].embedding

        # Calcula similaridades
        similarities = []
        for i, doc_embedding in enumerate(self.embeddings):
            sim = cosine_similarity(query_embedding, doc_embedding)
            similarities.append((self.documents[i], sim))

        # Retorna top_k mais similares
        similarities.sort(key=lambda x: x[1], reverse=True)
        return similarities[:top_k]

# Uso
search = SemanticSearch()
search.add_documents([
    "Python e excelente para data science e machine learning",
    "JavaScript e a linguagem da web, usada no frontend e backend",
    "Rust oferece seguranca de memoria sem garbage collector",
    "Go e otimo para sistemas distribuidos e microservices"
])

resultados = search.search("Qual linguagem usar para inteligencia artificial?")
for doc, score in resultados:
    print(f"[{score:.3f}] {doc}")

def get_embedding_reduced(text: str, dimensions: int = 256) -> list[float]:
    """Gera embedding com dimensionalidade reduzida"""
    response = client.embeddings.create(
        input=text,
        model="text-embedding-3-small",
        dimensions=dimensions  # Reduz de 1536 para 256
    )
    return response.data[0].embedding

# Embedding menor = menos armazenamento, busca mais rapida
embedding_full = get_embedding("Teste")           # 1536 dims
embedding_small = get_embedding_reduced("Teste")  # 256 dims

def preprocess_text(text: str) -> str:
    """Pre-processa texto antes de gerar embedding"""
    # Remove espacos extras
    text = " ".join(text.split())
    # Trunca se muito longo (aproximadamente 8000 tokens)
    max_chars = 30000  # ~8000 tokens
    if len(text) > max_chars:
        text = text[:max_chars]
    return text