Cohere API - Enterprise RAG-Focused API Service

pip install cohere

import cohere

# Initialize client
co = cohere.Client('YOUR_API_KEY')

# Use Command R+ for chat
response = co.chat(
    message="What is RAG? Please explain in simple terms.",
    model="command-r-plus"
)

print(response.text)

# Using the latest Command A model
response = co.chat(
    message="Hello, introduce Cohere",
    model="command-a"  # or use "command-r-plus"
)
print(response.text)

# Document-based conversation
response = co.chat(
    message="Summarize the key points of these documents",
    documents=[
        {
            "title": "AI Development", 
            "text": "Artificial intelligence has developed rapidly in recent years..."
        },
        {
            "title": "RAG Technology", 
            "text": "Retrieval Augmented Generation is a..."
        }
    ],
    model="command-r-plus"
)

print(response.text)

# View cited documents
for citation in response.citations:
    print(f"Citation: {citation['text']}")

texts = [
    "Machine learning is a branch of artificial intelligence",
    "Deep learning uses neural networks",
    "RAG combines retrieval and generation"
]

response = co.embed(
    texts=texts,
    model="embed-multilingual-v3.0",
    input_type="search_document"
)

print(f"Vector dimension: {len(response.embeddings[0])}")
print(f"First text vector: {response.embeddings[0][:5]}...")

import numpy as np

# 1. Prepare documents
documents = [
    "Python is a programming language",
    "Machine learning uses algorithms to learn from data",
    "The weather is nice today",
    "Deep learning is a subfield of machine learning"
]

# 2. Generate document vectors
doc_embeddings = co.embed(
    texts=documents,
    model="embed-multilingual-v3.0",
    input_type="search_document"
).embeddings

# 3. Generate query vector
query = "What is machine learning?"
query_embedding = co.embed(
    texts=[query],
    model="embed-multilingual-v3.0",
    input_type="search_query"
).embeddings[0]

# 4. Calculate similarity
scores = [
    np.dot(query_embedding, doc_emb)
    for doc_emb in doc_embeddings
]

# 5. Sort and display results
for idx in np.argsort(scores)[::-1]:
    print(f"{documents[idx]}: {scores[idx]:.4f}")

query = "What is machine learning?"
documents = [
    "Machine learning is an important branch of AI",
    "The weather is nice today",
    "Deep learning is a subfield of machine learning",
    "I like pizza"
]

response = co.rerank(
    query=query,
    documents=documents,
    model="rerank-multilingual-v3.0",
    top_n=2
)

# Display reranked results
for result in response.results:
    print(f"Relevance {result.relevance_score:.4f}: {documents[result.index]}")

import cohere

co = cohere.Client('YOUR_API_KEY')

class DocumentQA:
    def __init__(self, documents):
        self.documents = documents
        # Vectorize documents
        self.embeddings = co.embed(
            texts=documents,
            model="embed-multilingual-v3.0",
            input_type="search_document"
        ).embeddings
    
    def ask(self, question):
        # 1. Search relevant documents
        query_emb = co.embed(
            texts=[question],
            model="embed-multilingual-v3.0",
            input_type="search_query"
        ).embeddings[0]
        
        # 2. Calculate similarity and get top 5
        scores = [np.dot(query_emb, doc_emb) for doc_emb in self.embeddings]
        top_indices = np.argsort(scores)[-5:][::-1]
        relevant_docs = [self.documents[i] for i in top_indices]
        
        # 3. Rerank for precision
        reranked = co.rerank(
            query=question,
            documents=relevant_docs,
            model="rerank-multilingual-v3.0",
            top_n=3
        )
        
        # 4. Generate answer
        response = co.chat(
            message=question,
            documents=[{"text": relevant_docs[r.index]} for r in reranked.results],
            model="command-r-plus"
        )
        
        return response.text

# Usage
docs = ["Document 1 content...", "Document 2 content...", "Document 3 content..."]
qa_system = DocumentQA(docs)
answer = qa_system.ask("What is the main content of these documents?")
print(answer)

class SemanticSearch:
    def __init__(self, documents):
        self.documents = documents
        self.embeddings = co.embed(
            texts=documents,
            model="embed-multilingual-v3.0",
            input_type="search_document"
        ).embeddings
    
    def search(self, query, top_k=5):
        # 1. Vector search
        query_emb = co.embed(
            texts=[query],
            model="embed-multilingual-v3.0",
            input_type="search_query"
        ).embeddings[0]
        
        scores = [np.dot(query_emb, doc_emb) for doc_emb in self.embeddings]
        top_indices = np.argsort(scores)[-top_k*2:][::-1]
        candidates = [self.documents[i] for i in top_indices]
        
        # 2. Rerank for precision
        reranked = co.rerank(
            query=query,
            documents=candidates,
            model="rerank-multilingual-v3.0",
            top_n=top_k
        )
        
        # 3. Return results
        results = []
        for result in reranked.results:
            results.append({
                "document": candidates[result.index],
                "score": result.relevance_score
            })
        
        return results

# Usage
search_engine = SemanticSearch(documents)
results = search_engine.search("Machine learning related content", top_k=3)
for r in results:
    print(f"{r['score']:.4f}: {r['document'][:100]}...")