1"El gato duerme" → [0.12, -0.34, 0.87, ..., 0.23]  (1536 números)
2"El felino descansa" → [0.11, -0.33, 0.85, ..., 0.24]  (muy similar)
3"El coche es rojo" → [0.78, 0.12, -0.45, ..., -0.67]  (muy diferente)

1import numpy as np
2 
3def cosine_similarity(a, b):
4    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
5 
6# Resultado: 0 (opuestos) a 1 (idénticos)

1pip install openai numpy

1from openai import OpenAI
2import numpy as np
3 
4client = OpenAI()
5 
6def get_embedding(text: str) -> list[float]:
7    """Genera el embedding de un texto."""
8    response = client.embeddings.create(
9        model="text-embedding-3-small",
10        input=text
11    )
12    return response.data[0].embedding
13 
14# Ejemplo
15embedding = get_embedding("Hola mundo")
16print(f"Dimensiones: {len(embedding)}")  # 1536
17print(f"Primeros valores: {embedding[:5]}")

1def get_embeddings_batch(texts: list[str]) -> list[list[float]]:
2    """Genera embeddings para múltiples textos de una vez."""
3    response = client.embeddings.create(
4        model="text-embedding-3-small",
5        input=texts
6    )
7    return [item.embedding for item in response.data]
8 
9# Más eficiente que llamar uno por uno
10textos = ["Texto 1", "Texto 2", "Texto 3"]
11embeddings = get_embeddings_batch(textos)

1from openai import OpenAI
2import numpy as np
3 
4client = OpenAI()
5 
6# Base de datos de ejemplo
7documents = [
8    "Python es un lenguaje de programación",
9    "El café es una bebida popular",
10    "JavaScript se usa para desarrollo web",
11    "El té verde tiene antioxidantes",
12    "TypeScript añade tipos a JavaScript"
13]
14 
15# Generar embeddings de documentos
16doc_embeddings = []
17for doc in documents:
18    response = client.embeddings.create(
19        model="text-embedding-3-small",
20        input=doc
21    )
22    doc_embeddings.append(response.data[0].embedding)
23 
24def search(query: str, top_k: int = 3) -> list[tuple[str, float]]:
25    """Busca los documentos más similares a la query."""
26    # Embedding de la query
27    query_response = client.embeddings.create(
28        model="text-embedding-3-small",
29        input=query
30    )
31    query_embedding = query_response.data[0].embedding
32 
33    # Calcular similitudes
34    similarities = []
35    for i, doc_emb in enumerate(doc_embeddings):
36        sim = np.dot(query_embedding, doc_emb) / (
37            np.linalg.norm(query_embedding) * np.linalg.norm(doc_emb)
38        )
39        similarities.append((documents[i], sim))
40 
41    # Ordenar por similitud
42    similarities.sort(key=lambda x: x[1], reverse=True)
43    return similarities[:top_k]
44 
45# Prueba
46results = search("programación en la web")
47for doc, score in results:
48    print(f"{score:.3f}: {doc}")
49 
50# Output:
51# 0.823: JavaScript se usa para desarrollo web
52# 0.801: TypeScript añade tipos a JavaScript
53# 0.756: Python es un lenguaje de programación

1def rag_query(question: str, documents: list[str]) -> str:
2    """Responde preguntas usando documentos relevantes."""
3    # Buscar documentos relevantes
4    relevant_docs = search(question, top_k=3)
5    context = "\n".join([doc for doc, _ in relevant_docs])
6 
7    # Generar respuesta con contexto
8    response = client.chat.completions.create(
9        model="gpt-4o-mini",
10        messages=[
11            {
12                "role": "system",
13                "content": f"Responde basándote en este contexto:\n{context}"
14            },
15            {"role": "user", "content": question}
16        ]
17    )
18 
19    return response.choices[0].message.content

1def find_duplicates(texts: list[str], threshold: float = 0.95) -> list[tuple]:
2    """Encuentra textos duplicados o muy similares."""
3    embeddings = get_embeddings_batch(texts)
4    duplicates = []
5 
6    for i in range(len(texts)):
7        for j in range(i + 1, len(texts)):
8            sim = cosine_similarity(
9                np.array(embeddings[i]),
10                np.array(embeddings[j])
11            )
12            if sim > threshold:
13                duplicates.append((texts[i], texts[j], sim))
14 
15    return duplicates

1from sklearn.cluster import KMeans
2 
3def cluster_texts(texts: list[str], n_clusters: int = 5):
4    """Agrupa textos similares."""
5    embeddings = get_embeddings_batch(texts)
6 
7    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
8    labels = kmeans.fit_predict(embeddings)
9 
10    clusters = {}
11    for text, label in zip(texts, labels):
12        if label not in clusters:
13            clusters[label] = []
14        clusters[label].append(text)
15 
16    return clusters

1import chromadb
2from chromadb.utils import embedding_functions
3 
4# Inicializar
5client = chromadb.Client()
6openai_ef = embedding_functions.OpenAIEmbeddingFunction(
7    api_key="sk-...",
8    model_name="text-embedding-3-small"
9)
10 
11# Crear colección
12collection = client.create_collection(
13    name="mi_coleccion",
14    embedding_function=openai_ef
15)
16 
17# Añadir documentos
18collection.add(
19    documents=["Documento 1", "Documento 2"],
20    ids=["id1", "id2"]
21)
22 
23# Buscar
24results = collection.query(
25    query_texts=["mi búsqueda"],
26    n_results=5
27)

1from sentence_transformers import SentenceTransformer
2model = SentenceTransformer('all-MiniLM-L6-v2')
3embedding = model.encode("Tu texto")