Typical Application Scenarios¶

# RAG system implementation example
from sentence_transformers import SentenceTransformer
import vector_db  # Hypothetical vector database client

# 1. Initialize components
model = SentenceTransformer('all-MiniLM-L6-v2')
db = vector_db.Client("localhost:6333")
collection = db.get_collection("company_docs")

# 2. User query
user_query = "What is the company's annual leave policy?"

# 3. Vectorize the query
query_embedding = model.encode(user_query)

# 4. Retrieve relevant documents
results = collection.search(
    vector=query_embedding,
    top_k=5,
    filter={"department": "HR"}  # Optional filter
)

# 5. Build context
context = "\n\n".join([r.content for r in results])

# 6. Build prompt
prompt = f"""Answer the user's question based on the following information. If the information is insufficient, please say you don't know.

Context:
{context}

User Question: {user_query}

Answer:"""

# 7. Call LLM to generate answer
response = llm.generate(prompt)
print(response)

# Common chunking strategies

# 1. Fixed-size chunking (simplest)
def chunk_by_size(text, chunk_size=500, overlap=50):
    chunks = []
    for i in range(0, len(text), chunk_size - overlap):
        chunks.append(text[i:i + chunk_size])
    return chunks

# 2. Chunk by paragraph (maintain semantic integrity)
def chunk_by_paragraph(text):
    paragraphs = text.split('\n\n')
    return [p for p in paragraphs if p.strip()]

# 3. Recursive chunking (more intelligent)
def chunk_recursively(text, delimiters=['\n\n', '\n', '.', '!']):
    # Try larger delimiters first, refine progressively
    pass

# Recommendation system vector representation
user_vector = model.encode("User A's interest features")
item_vector = model.encode("Item B's features")

# Calculate user's interest score for the item
score = np.dot(user_vector, item_vector)  # Dot product
top_items = find_top_k(score, k=10)

# Movie recommendation system example
from sentence_transformers import SentenceTransformer
import numpy as np

model = SentenceTransformer('all-MiniLM-L6-v2')

# Movie database
movies = [
    {"id": 1, "title": "Interstellar", "genre": "Sci-Fi"},
    {"id": 2, "title": "Titanic", "genre": "Romance"},
    {"id": 3, "title": "Inception", "genre": "Sci-Fi"},
    {"id": 4, "title": "Forrest Gump", "genre": "Drama"},
]

# Build movie vectors
movie_vectors = model.encode([m["title"] for m in movies])

# User preferences
user_liked = "Sci-fi movies space time travel"
user_vector = model.encode(user_liked)

# Calculate similarity
similarities = np.dot(user_vector, movie_vectors.T)

# Sort and return recommendations
top_indices = np.argsort(similarities)[::-1][:2]
recommendations = [movies[i]["title"] for i in top_indices]

print(f"Recommended movies: {recommendations}")
# Output: ['Interstellar', 'Inception']

# Semantic search code example
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

# Document corpus
documents = [
    "Artificial intelligence will change our way of life",
    "Machine learning is an important branch of AI",
    "The weather is really nice today, good for going out",
    "Deep learning has made breakthroughs in image recognition",
    "The latest iPhone uses the A17 chip",
]

# Vectorize documents
doc_vectors = model.encode(documents)

# Semantic search query
query = "What is deep learning?"
query_vector = model.encode(query)

# Calculate similarity
from sklearn.metrics.pairwise import cosine_similarity
similarities = cosine_similarity([query_vector], doc_vectors)[0]

# Return most relevant document
top_idx = np.argsort(similarities)[::-1][0]
print(f"Most relevant document: {documents[top_idx]}")
# Output: 'Deep learning has made breakthroughs in image recognition'

# Cross-language semantic search
query_vector = model.encode("How to cook pasta?")  # English query

# Chinese documents can also be retrieved
chinese_docs = [
    "How to make spaghetti",
    "What's the weather like in Beijing",
    "Learn Python programming",
]

doc_vectors = model.encode(chinese_docs)
# Through multi-language models, semantically similar content returns high similarity

# Search by image example
import clip
import torch
from PIL import Image

# Load CLIP model
model, preprocess = clip.load("ViT-B/32", device="cpu")

# Vectorize image database
def encode_image(img_path):
    image = preprocess(Image.open(img_path)).unsqueeze(0)
    with torch.no_grad():
        image_features = model.encode_image(image)
    return image_features.numpy()

# Image collection
image_paths = ["cat1.jpg", "cat2.jpg", "dog.jpg"]
image_vectors = [encode_image(p) for p in image_paths]

# Query image
query_image = preprocess(Image.open("query_cat.jpg")).unsqueeze(0)
query_vector = model.encode_image(query_image).numpy()

# Find most similar image
similarities = cosine_similarity(query_vector, np.array(image_vectors))
most_similar_idx = np.argmax(similarities)
print(f"Most similar image: {image_paths[most_similar_idx]}")

# Financial fraud detection example
from sklearn.cluster import KMeans
import numpy as np

# Normal transaction feature vectors
normal_transactions = np.random.rand(1000, 20)  # 1000 normal transactions, 20 dimensions

# Learn normal patterns
kmeans = KMeans(n_clusters=10, random_state=42)
kmeans.fit(normal_transactions)

# Detect new transaction
new_transaction = np.random.rand(1, 20)

# Calculate distance to nearest normal center
distance = np.min(np.linalg.norm(
    new_transaction - kmeans.cluster_centers_,
    axis=1
))

# Judge if anomalous
threshold = 2.5
is_fraud = distance > threshold
print(f"Transaction anomalous: {is_fraud}, distance: {distance:.2f}")

# AI Agent memory system
class AgentMemory:
    def __init__(self, vector_db, embed_model):
        self.db = vector_db
        self.embed = embed_model

    def add_memory(self, content, memory_type="experience"):
        """Add memory"""
        vector = self.embed.encode(content)
        self.db.insert({
            "vector": vector,
            "content": content,
            "type": memory_type
        })

    def retrieve(self, query, top_k=5):
        """Retrieve relevant memories"""
        query_vector = self.embed.encode(query)
        results = self.db.search(query_vector, top_k=top_k)
        return [r["content"] for r in results]

    def reflect(self, recent_experiences):
        """Reflection and summarization: convert short-term experiences to long-term memory"""
        summary = self.llm.summarize(recent_experiences)
        self.add_memory(summary, memory_type="reflection")