Today we are building a research assistant that demonstrates exactly where large language models sit inside the broader deep learning landscape. Instead of reading another abstract comparison, you will wire an embedding model and an LLM together so the difference becomes tangible in code. If you are evaluating how to mix retrieval, classification, and generation in your own stack, this project gives you a concrete starting point.
What you'll need
- Python 3.10 or newer
- An Oxlo.ai API key from https://portal.oxlo.ai
- The OpenAI SDK:
pip install openai
Step 1: Prepare the knowledge base
I started by hard-coding a few canonical definitions so our retriever has something to search. In production you would point this at your documentation or a vector store, but a small dictionary keeps the example self-contained.
KNOWLEDGE_BASE = [
{
"id": "dl-1",
"text": "Deep learning is a subset of machine learning based on artificial neural networks with multiple layers. It powers computer vision, speech recognition, recommendation systems, and natural language processing."
},
{
"id": "llm-1",
"text": "A large language model is a specific kind of deep learning model, typically based on the transformer architecture, trained on vast text corpora to predict and generate language."
},
{
"id": "llm-2",
"text": "LLMs such as Llama, Qwen, and DeepSeek are distinguished by their emergent reasoning abilities, in-context learning, and billions of parameters, but they are still fundamentally neural networks."
},
{
"id": "dl-2",
"text": "Not all deep learning models are LLMs. Convolutional neural networks for image classification and waveform models for text-to-speech are deep learning systems that do not use the transformer architecture or next-token prediction."
}
]Step 2: Embed the chunks with Oxlo.ai
Embeddings are dense vector representations produced by deep learning encoders. Oxlo.ai hosts BGE-Large, which I use to turn our text chunks into vectors. Notice that this step is pure deep learning, not yet an LLM.
from openai import OpenAI
import numpy as np
client = OpenAI(base_url="https://api.oxlo.ai/v1", api_key="YOUR_OXLO_API_KEY")
def get_embedding(text: str) -> list[float]:
response = client.embeddings.create(
model="bge-large",
input=[text]
)
return response.data[0].embedding
# Pre-compute embeddings for every chunk
chunk_embeddings = []
for chunk in KNOWLEDGE_BASE:
chunk_embeddings.append({
**chunk,
"embedding": get_embedding(chunk["text"])
})
print(f"Embedded {len(chunk_embeddings)} chunks.")Step 3: Build the retriever
When a user asks a question, we embed the query using the same BGE-Large model, then score cosine similarity against our knowledge base. The highest scoring chunk becomes the grounding context for the LLM.
def cosine_similarity(a: list[float], b: list[float]) -> float:
a_vec = np.array(a)
b_vec = np.array(b)
return float(np.dot(a_vec, b_vec) / (np.linalg.norm(a_vec) * np.linalg.norm(b_vec)))
def retrieve_chunk(query: str) -> dict:
query_embedding = get_embedding(query)
best = max(
chunk_embeddings,
key=lambda c: cosine_similarity(query_embedding, c["embedding"])
)
return bestStep 4: Build the generator with a system prompt
Now we bring in the LLM. I use Llama 3.3 70B on Oxlo.ai because it follows instructions tightly and keeps explanations grounded. The system prompt below forces the model to cite the retrieved definition and explicitly state whether the topic is deep learning in general or an LLM specifically.
SYSTEM_PROMPT = """You are a precise technical assistant.
You have been given a single retrieved definition or fact as context.
Answer the user's question using only that context.
If the context describes broad deep learning architectures, say so clearly.
If the context describes large language models specifically, say so clearly.
Always explain the distinction in one concise paragraph."""The generator function is a standard chat completion call to Oxlo.ai.
def generate_answer(query: str, context: str) -> str:
response = client.chat.completions.create(
model="llama-3.3-70b",
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query}"},
],
temperature=0.2,
)
return response.choices[0].message.contentStep 5: Assemble the agent
The final pipeline is a two-stage agent: deep learning retrieves, the LLM generates. This separation mirrors how real production systems work. Oxlo.ai makes it easy to keep both stages on one platform with a single API key and request-based pricing that does not balloon when your context grows.
class ConceptAgent:
def ask(self, query: str) -> str:
chunk = retrieve_chunk(query)
answer = generate_answer(query, chunk["text"])
return answer
agent = ConceptAgent()Run it
Here is how I tested the finished agent. The query is intentionally vague to see whether the pipeline can disambiguate the two fields.
query = "What is the difference between LLMs and deep learning?"
answer = agent.ask(query)
print(answer)Example output:
Large language models are a specific kind of deep learning model, typically based on the transformer architecture, trained on vast text corpora to predict and generate language. Deep learning, however, is the broader field that also includes convolutional networks, waveform models, and other architectures that do not use next-token prediction. Therefore, every LLM is a deep learning model, but not every deep learning model is an LLM.Wrap-up
You now have a minimal retrieval-augmented agent that uses Oxlo.ai for both embedding and generation. A concrete next step is to swap the generator to qwen-3-32b if you need multilingual explanations, or to add vision by passing architecture diagrams to kimi-k2.6 and asking it to classify whether the depicted model is a transformer-based LLM or a CNN. Keep the retriever on bge-large and you have a clean separation between deep learning representation and LLM reasoning.
Top comments (0)