What are all the Python libraries used for AI Engineering (Agent Development, Fine-Tuning LLM, etc.) and what are they used for?

Python Libraries for AI Engineering

The AI engineering ecosystem is built on a rich set of Python libraries. Here is a comprehensive breakdown by use case.

1. LLM API Clients

Libraries for calling hosted LLM APIs directly.

openai

pip install openai

anthropic

pip install anthropic

google-generativeai

pip install google-generativeai

boto3

pip install boto3

litellm

pip install litellm

pythonCopy
# litellm — call any provider with the same code
from litellm import completion

response = completion(model="gpt-4o", messages=[{"role": "user", "content": "Hello"}])
response = completion(model="claude-3-5-sonnet", messages=[{"role": "user", "content": "Hello"}])
response = completion(model="gemini/gemini-1.5-pro", messages=[{"role": "user", "content": "Hello"}])

2. LLM Orchestration Frameworks

High-level frameworks for chaining LLM calls, tools, and data sources.

langchain

llama-index

haystack

dspy

guidance

pythonCopy
# LangChain — simple RAG chain
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import FAISS

qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o"),
    retriever=FAISS.load_local("index", embeddings).as_retriever()
)
answer = qa_chain.invoke("What is LoRA?")

pythonCopy
# LlamaIndex — document Q&A
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("Summarize the key findings")

3. Agent Development

Libraries for building autonomous, multi-step AI agents.

langgraph

autogen

crewai

smolagents

agno

openai-agents

pythonCopy
# LangGraph — stateful agent with tools
from langgraph.graph import StateGraph, END
from typing import TypedDict

class AgentState(TypedDict):
    messages: list
    tool_output: str

def call_llm(state: AgentState):
    # call LLM with current messages
    return {"messages": state["messages"] + [llm_response]}

def use_tool(state: AgentState):
    # execute tool based on LLM decision
    return {"tool_output": tool_result}

graph = StateGraph(AgentState)
graph.add_node("llm", call_llm)
graph.add_node("tool", use_tool)
graph.add_edge("llm", "tool")
graph.add_edge("tool", END)
agent = graph.compile()

pythonCopy
# CrewAI — role-based multi-agent team
from crewai import Agent, Task, Crew

researcher = Agent(role="Researcher", goal="Find relevant info", llm="gpt-4o")
writer = Agent(role="Writer", goal="Write clear summaries", llm="gpt-4o")

task = Task(description="Research and summarise PEFT methods", agent=researcher)
crew = Crew(agents=[researcher, writer], tasks=[task])
result = crew.kickoff()

4. Fine-Tuning LLMs

Libraries for training and adapting LLM weights.

torch

torch.cuda

.to("cuda")

transformers

peft

trl

bitsandbytes

unsloth

axolotl

datasets

pythonCopy
# Full fine-tuning pipeline with TRL + PEFT
from trl import SFTTrainer, SFTConfig
from peft import LoraConfig
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B")

trainer = SFTTrainer(
    model=model,
    args=SFTConfig(output_dir="./output", num_train_epochs=3),
    train_dataset=dataset,
    peft_config=LoraConfig(r=16, lora_alpha=32, task_type="CAUSAL_LM")
)
trainer.train()

pythonCopy
# PyTorch + CUDA — device-agnostic training setup
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")          # cuda
print(torch.cuda.get_device_name(0))      # NVIDIA A100-SXM4-80GB

# Move model and tensors to GPU
model = model.to(device)
input_ids = input_ids.to(device)

# Mixed precision (faster training, less VRAM)
with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
    outputs = model(input_ids)
    loss = outputs.loss

pythonCopy
# Unsloth — faster fine-tuning
from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True
)
model = FastLanguageModel.get_peft_model(model, r=16, lora_alpha=32)

5. Embeddings & Vector Stores

Libraries for generating embeddings and storing/searching them.

sentence-transformers

tiktoken

faiss-cpu

faiss-gpu

chromadb

pinecone-client

weaviate-client

qdrant-client

pythonCopy
# sentence-transformers + FAISS local vector search
from sentence_transformers import SentenceTransformer
import faiss, numpy as np

model = SentenceTransformer("all-MiniLM-L6-v2")
docs = ["LoRA is a PEFT method", "RAG retrieves context", "Transformers use attention"]

embeddings = model.encode(docs).astype(np.float32)
index = faiss.IndexFlatL2(embeddings.shape[1])
index.add(embeddings)

query_vec = model.encode(["what is LoRA?"]).astype(np.float32)
distances, indices = index.search(query_vec, k=2)
print([docs[i] for i in indices[0]])

6. Model Serving & Inference

Libraries for deploying and serving LLMs in production.

vllm

ollama

llama-cpp-python

bentoml

ray[serve]

pythonCopy
# vLLM — serve and query
from vllm import LLM, SamplingParams

llm = LLM(model="meta-llama/Llama-3.2-3B")
outputs = llm.generate(
    ["Explain attention mechanisms"],
    SamplingParams(temperature=0.7, max_tokens=200)
)
print(outputs[0].outputs[0].text)

7. Evaluation & Observability

Libraries for testing, evaluating, and monitoring LLM applications.

ragas

deepeval

langsmith

langfuse

wandb

mlflow

pythonCopy
# LangSmith — trace every LLM call automatically
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-langsmith-api-key"
os.environ["LANGCHAIN_PROJECT"] = "my-rag-app"

# All LangChain calls are now automatically traced in LangSmith dashboard
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o")
response = llm.invoke("What is LoRA?")
# → Trace appears in LangSmith with latency, tokens, cost, inputs/outputs

pythonCopy
# RAGAS — evaluate RAG pipeline quality
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_recall
from datasets import Dataset

eval_data = Dataset.from_dict({
    "question": ["What is LoRA?"],
    "answer": ["LoRA is a PEFT method using low-rank matrices."],
    "contexts": [["LoRA adds trainable low-rank matrices to frozen attention layers."]],
    "ground_truth": ["LoRA (Low-Rank Adaptation) is a parameter-efficient fine-tuning method."]
})

results = evaluate(eval_data, metrics=[faithfulness, answer_relevancy, context_recall])
print(results)

pythonCopy
# DeepEval — LLM unit tests
from deepeval import assert_test
from deepeval.metrics import HallucinationMetric, AnswerRelevancyMetric
from deepeval.test_case import LLMTestCase

test_case = LLMTestCase(
    input="What is LoRA?",
    actual_output="LoRA is a PEFT method.",
    context=["LoRA adds trainable matrices to frozen layers."]
)
assert_test(test_case, [HallucinationMetric(threshold=0.5), AnswerRelevancyMetric(threshold=0.7)])

8. Data Processing for AI

Libraries for preparing training data and working with tokens.

datasets

tokenizers

tiktoken

docling

unstructured

pythonCopy
# datasets — load and preprocess training data
from datasets import load_dataset

dataset = load_dataset("tatsu-lab/alpaca")        # 52K instruction examples
dataset = load_dataset("json", data_files="custom.jsonl")

# Tokenize for fine-tuning
def tokenize(example):
    return tokenizer(example["text"], truncation=True, max_length=512)

tokenized = dataset.map(tokenize, batched=True)

Quick Reference by Task

openai

anthropic

litellm

langchain

llama-index

haystack

langgraph

crewai

autogen

smolagents

torch

torch.cuda

transformers

peft

trl

unsloth

sentence-transformers

faiss

chromadb

qdrant-client

vllm

ollama

bentoml

ragas

deepeval

wandb

mlflow

langfuse

langsmith

datasets

unstructured

docling

Interview tip: Know the distinction between orchestration (

textCopy

langchain

,

textCopy

llama-index

) and agent (

textCopy

langgraph

,

textCopy

crewai

) libraries — they are often confused. Also know that

textCopy

trl

+

textCopy

peft

is the standard fine-tuning stack, and

textCopy

vllm

is the go-to serving framework for production.

Learn more at HuggingFace Docs, LangChain Docs, and LangGraph Docs.