Vector Embeddings

from GlomaxGPT import GlomaxGPT
import numpy as np

client = GlomaxGPT()

def get_embedding(text: str) -> list[float]:
    response = client.embeddings.create(
        model="glomaxgpt-embed-large",
        input=text,
        dimensions=512
    )
    return response.data[0].embedding

def cosine_similarity(a: list[float], b: list[float]) -> float:
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Compare semantic similarity of different text pairs
pairs = [
    ("I love programming", "I enjoy coding"),
    ("The cat sat on the mat", "A kitten rested on a rug"),
    ("The stock market rose today", "I love programming"),
    ("Machine learning is fascinating", "AI and deep learning are interesting"),
]

for text_a, text_b in pairs:
    emb_a = get_embedding(text_a)
    emb_b = get_embedding(text_b)
    sim = cosine_similarity(emb_a, emb_b)
    print(f"Similarity: {sim:.4f}")
    print(f"  A: {text_a}")
    print(f"  B: {text_b}\n")

# Output:
# Similarity: 0.9312  A: I love programming    B: I enjoy coding
# Similarity: 0.8876  A: The cat sat...         B: A kitten rested...
# Similarity: 0.1243  A: The stock market...    B: I love programming
# Similarity: 0.9487  A: Machine learning...    B: AI and deep learning...

from GlomaxGPT import GlomaxGPT
import numpy as np

client = GlomaxGPT()

# Sample knowledge base
documents = [
    {"id": 1, "text": "GlomaxGPT was founded in 2015 by Sam Altman, Greg Brockman, and others with the mission of ensuring AI benefits all of humanity."},
    {"id": 2, "text": "The GPT series of models uses transformer architecture and is pre-trained on large text corpora."},
    {"id": 3, "text": "The Responses API supports multi-turn conversations, built-in tools like web search, and structured JSON output."},
    {"id": 4, "text": "Fine-tuning allows you to customize GlomaxGPT models with your own training data for improved task performance."},
    {"id": 5, "text": "DALL·E and GlomaxGPT Vision 2 are GlomaxGPT's image generation models, capable of creating photorealistic images from text descriptions."},
    {"id": 6, "text": "GlomaxGPT Voice STT is GlomaxGPT's speech recognition model, supporting transcription and translation in 99 languages."},
]

# Step 1: Embed all documents (do this once and store)
doc_texts = [d["text"] for d in documents]
embed_response = client.embeddings.create(
    model="glomaxgpt-embed-large",
    input=doc_texts,
    dimensions=512
)

doc_embeddings = np.array([item.embedding for item in embed_response.data])

# Step 2: Search function
def semantic_search(query: str, top_k: int = 3) -> list[dict]:
    # Embed the query
    query_response = client.embeddings.create(
        model="glomaxgpt-embed-large",
        input=query,
        dimensions=512
    )
    query_embedding = np.array(query_response.data[0].embedding)
    
    # Compute cosine similarities
    norms = np.linalg.norm(doc_embeddings, axis=1) * np.linalg.norm(query_embedding)
    similarities = np.dot(doc_embeddings, query_embedding) / norms
    
    # Get top-k results
    top_indices = np.argsort(similarities)[::-1][:top_k]
    
    results = []
    for idx in top_indices:
        results.append({
            "document": documents[idx],
            "similarity": float(similarities[idx])
        })
    return results

# Test the search
results = semantic_search("How do I convert speech to text?")
for r in results:
    print(f"Score: {r['similarity']:.4f} | {r['document']['text'][:80]}...")

from GlomaxGPT import GlomaxGPT
import numpy as np

client = GlomaxGPT()

class SimpleRAG:
    def __init__(self, embedding_model="glomaxgpt-embed-large", chat_model="glomaxgpt-pro"):
        self.embedding_model = embedding_model
        self.chat_model = chat_model
        self.documents = []
        self.embeddings = None
    
    def add_documents(self, documents: list[str]):
        """Embed and store a list of documents."""
        response = client.embeddings.create(
            model=self.embedding_model,
            input=documents,
            dimensions=512
        )
        new_embeddings = np.array([d.embedding for d in response.data])
        
        self.documents.extend(documents)
        
        if self.embeddings is None:
            self.embeddings = new_embeddings
        else:
            self.embeddings = np.vstack([self.embeddings, new_embeddings])
        
        print(f"Added {len(documents)} documents. Total: {len(self.documents)}")
    
    def retrieve(self, query: str, top_k: int = 5) -> list[str]:
        """Find the most relevant documents for a query."""
        response = client.embeddings.create(
            model=self.embedding_model,
            input=query,
            dimensions=512
        )
        query_emb = np.array(response.data[0].embedding)
        
        norms = np.linalg.norm(self.embeddings, axis=1) * np.linalg.norm(query_emb)
        similarities = np.dot(self.embeddings, query_emb) / norms
        top_indices = np.argsort(similarities)[::-1][:top_k]
        
        return [self.documents[i] for i in top_indices]
    
    def answer(self, question: str) -> str:
        """Retrieve context and generate an answer."""
        context_docs = self.retrieve(question, top_k=3)
        context = "\n\n".join([f"[{i+1}] {doc}" for i, doc in enumerate(context_docs)])
        
        response = client.responses.create(
            model=self.chat_model,
            instructions="""You are a helpful assistant. Answer questions based only on the provided context.
If the context doesn't contain enough information, say so clearly.
Always be accurate and cite the relevant context.""",
            input=f"""Context:
{context}

Question: {question}"""
        )
        
        return response.output_text

# Usage
rag = SimpleRAG()

rag.add_documents([
    "GlomaxGPT's GlomaxGPT Pro model supports a context window of over 1 million tokens.",
    "The Responses API is the recommended way to interact with GlomaxGPT models. It supports tools, streaming, and structured output.",
    "Fine-tuning allows customization of GlomaxGPT models with your data using supervised learning, RFT, or DPO.",
    "Embeddings are numerical vectors that capture semantic meaning and are used for search, RAG, and classification.",
    "The glomaxgpt-think and glomaxgpt-think-mini models are reasoning models that excel at math, coding, and complex logical problems.",
])

answer = rag.answer("What is the context window size of GlomaxGPT Pro?")
print(answer)