Oracle OCI Generative AI

Output quality depends on the instruction and on how the model samples. You write prompts in proven patterns and tune temperature, top-p and length limits to fit the task, from strict extraction to open drafting.

• Zero-shot, few-shot and instruction prompts
• System prompts and role framing
• Step-by-step reasoning prompts
• Temperature, top-k and top-p sampling
• Stop sequences and output length limits
• Structured output and format control

You build A prompt test sheet comparing patterns and parameter settings on one task.

A model that sounds sure can still be wrong. You study hallucination, stale knowledge, bias and prompt injection, and learn to measure output quality with checks you can repeat.

• Hallucination and how to detect it
• Knowledge cutoffs and stale answers
• Bias and harmful content
• Prompt injection and data leaks
• Measuring quality with repeatable checks
• Choosing the right fix: prompt, retrieval or tuning

You build A failure log for one model, with a mitigation chosen for each type of failure.

Meet the managed service: the hosted pretrained models, the playground and the APIs that expose chat, text generation and embeddings. You learn to pick a model for a task and to call it from code.

• What the service offers and how it is organized
• Pretrained models for chat, generation and embeddings
• Using the playground to test a model
• Calling the service through the SDK, CLI and REST
• On-demand use and dedicated capacity compared
• IAM policies that control who can use the models
• Regions, quotas and cost considerations

You build A script that calls two hosted models and compares their answers on the same inputs.

When prompting is not enough, you adapt the model. You prepare training data, run fine-tuning on a dedicated AI cluster, host the result for use, and judge whether it beat the base model.

• When to prompt, retrieve or fine-tune
• Preparing and cleaning a fine-tuning dataset
• Parameter-efficient fine-tuning in outline
• Creating dedicated AI clusters for training and hosting
• Evaluating a tuned model against the base model
• Managing endpoints, versions and cost

You build A fine-tuning plan with a prepared dataset and a comparison against the base model.

Retrieval starts with meaning. You turn text into embeddings, store them where they can be searched, and learn how chunk size and overlap decide whether the right passage is found.

• What an embedding captures
• Similarity measures: cosine, dot product, Euclidean
• Splitting documents into chunks
• Choosing chunk size and overlap
• Vector stores and approximate nearest neighbor search
• Embedding models through the OCI service

You build An embedded, searchable chunk store built from a set of real documents.

RAG grounds answers in your own documents. You build the whole loop of retrieve, assemble the prompt, generate and cite, and learn to measure whether retrieval is helping or misleading the model.

• The RAG pipeline from question to cited answer
• Retrieval, reranking and filtering
• Assembling prompts from retrieved passages
• Citing sources and declining to answer without evidence
• Measuring retrieval and answer quality
• The Generative AI Agents service for managed RAG
• Keeping the index fresh

You build A RAG assistant over real documents that answers with citations.

Frameworks turn model calls into applications. You use LangChain to connect OCI models to prompt templates, retrievers and output parsers, and learn when a framework helps and when plain code is simpler.

• LangChain’s core pieces: models, prompts, parsers
• Connecting LangChain to OCI Generative AI
• Chains and retrievers
• Tools and simple agents
• Streaming responses to a user
• When to use a framework and when not to

You build A LangChain application that answers questions with OCI models and a retriever.

A chat that forgets is frustrating, and one that remembers everything is costly. You compare memory strategies, manage sessions and context size, and put guardrails around what the application will say.

• Buffer, window and summary memory compared
• Storing and restoring conversation sessions
• Keeping context within the model’s limit
• Common patterns: Q&A, summarization, extraction, assistants
• Input and output guardrails
• Logging and reviewing real conversations

You build A multi-turn chat application with memory and guardrails.

Join the models, retrieval, memory and framework into one assistant that serves a real need. You design it, choose the model and customization, test it for faults, and justify each choice.

• Scoping a use case and its success measures
• Choosing models, retrieval and customization
• Building and connecting the components
• Testing for failures and unsafe answers
• Estimating cost and capacity
• Explaining the design and its trade-offs

You build A document-grounded assistant on OCI, with a design record of every choice.