C1000-185 Sample Questions & Answers

Indirect prompt injection occurs when the malicious instruction comes from a data source (like a retrieved document) rather than the direct user input. Therefore, input validation on the user's prompt is ineffective. The best defense is to architect the prompt template to create a clear separation of concerns. The system prompt should explicitly instruct the LLM that the retrieved content is for informational purposes only and that any instructions within it should be ignored. This creates a logical barrier, making it much harder for the model to be manipulated by the content it processes.

The {{product_name}} and {{features}} placeholders in the template are defined as prompt variables. When making an API call or using the template, the developer provides the actual values for these variables, which are then substituted into the template to form the final prompt sent to the model.

This strategy directly addresses all key requirements. Fine-tuning (either full or PEFT) is the best method for creating a model that is highly specialized for a specific task when a quality dataset is available. It will yield superior performance compared to prompting alone. Most importantly, the resulting custom model is an asset that can be deployed entirely on-premises, satisfying the strict data privacy and security constraints by ensuring no sensitive data ever leaves their controlled environment.

A Document Loader is the first step in the RAG pipeline, responsible for ingesting data from various sources (PDFs, websites, databases) into a format LangChain can process.

A Vector Store (like Chroma or Milvus) stores the document embeddings. A Retriever is the LangChain component that interfaces with the Vector Store to find and return the most relevant document chunks based on the user's query.

This is the core generative component. LangChain uses wrappers for various LLMs (including those on watsonx.ai) to provide a standardized interface for sending the combined prompt (user query + retrieved context) and receiving the final generated answer.

This describes the standard MLOps workflow in watsonx.ai and IBM Cloud Pak for Data. Models and other assets are developed within a project. To make them operational, they are promoted to a dedicated deployment space. From there, an online deployment can be created, which provisions the necessary resources and exposes the model via a stable, scalable REST API endpoint.

For this use case, the constraints of budget, GPU capacity, low latency, and running on developer machines are paramount. The smallest instruction-tuned code model is the optimal choice. Smaller models are significantly cheaper to run, have lower latency, and require less memory/GPU, making them suitable for local deployment. While the largest model might offer slightly higher quality, the operational costs and resource requirements would be prohibitive for the startup's constraints. An instruction-tuned model is also crucial for a chat/assistant-like application.

This is the core difference. Top-K sampling considers a static pool size (e.g., the top 50 most likely tokens). Top-P sampling is dynamic; it considers the smallest set of tokens whose cumulative probability is greater than or equal to the value 'p'. If the model is very certain about the next token, this set might be very small (e.g., 2-3 tokens). If the model is uncertain, the set could be much larger. This makes Top-P generally more adaptive and often preferred over Top-K.

The rank (r) directly controls the size of the low-rank adaptation matrices (A and B). A higher 'r' means larger matrices, which translates to more trainable parameters. This allows the model to learn more complex adaptations (higher expressiveness), but it also increases the computational and memory requirements during training. Furthermore, a rank that is too high relative to the size and complexity of the fine-tuning dataset can lead to overfitting, where the model memorizes the training data instead of generalizing.

For a RAG system that must handle multiple languages, a dedicated multilingual embedding model is essential. Models like paraphrase-multilingual-mpnet-base-v2 are trained on many languages and map semantically similar sentences to nearby points in the vector space, regardless of the source language. This allows a single vector store to handle documents in both English and Japanese, and enables cross-lingual retrieval (e.g., asking a question in English and retrieving a relevant Japanese document). Using separate models would be complex and would not support cross-lingual search.

False. An 'AI Asset' in watsonx.ai is a broad term. Besides custom models, other assets such as saved prompt templates from the Prompt Lab, Python functions, and data assets can also be promoted to a deployment space and deployed for operational use.

The requirements specify strict data privacy (on-premises/private cloud), confidentiality, and the need for factual citations. RAG is the optimal pattern for grounding answers in specific documents (reducing hallucinations and enabling citations). Using an on-premises deployment of watsonx.ai satisfies the data sovereignty requirement, and IBM Granite models are enterprise-grade foundation models suitable for business summarization tasks.

The IBM Granite model family includes specific variants trained on code datasets (granite-code). The granite-20b-code model is specifically designed and optimized for code generation, translation, and explanation tasks in languages like Python and Java. FLAN-T5 is an instruction-tuned text model, and while Llama and Elyza have capabilities, Granite Code is the native IBM enterprise option for this specific domain.

RAG provides the model with factual context that it must use to generate the answer, significantly reducing hallucinations. Lowering temperature (decoding parameters) makes the model more deterministic and less likely to 'invent' creative but incorrect facts. Increasing temperature would actually increase hallucination risk.

RAG provides the model with factual context that it must use to generate the answer, significantly reducing hallucinations. Lowering temperature (decoding parameters) makes the model more deterministic and less likely to 'invent' creative but incorrect facts. Increasing temperature would actually increase hallucination risk.

If a model stops mid-sentence, it likely hit the 'Max Tokens' limit. Increasing this allows for longer generation. To prevent indefinite rambling when the limit is raised, 'Stop Sequences' (e.g., a period, newline, or specific token like 'END') should be configured to signal the model to cease generation at a logical point.

In IBM watsonx.ai Prompt Lab, variables are defined using single curly braces, such as {product_name}. When the prompt is saved as a template or used via API, these placeholders are recognized as input variables that can be dynamically populated.

Prompt Tuning (a form of Parameter-Efficient Fine-Tuning or PEFT) involves training a small set of learnable parameters (soft prompts) that are prepended to the input, while keeping the underlying foundation model frozen. This is highly efficient compared to full fine-tuning, requires less compute, and is ideal for classification tasks with a moderate labeled dataset (like 2,000 examples) where adapting the style/format is needed without changing the model's core knowledge.

The watsonx.ai Tuning Studio requires training data to be in JSONL (JSON Lines) format. Each line in the file must be a valid JSON object containing input (the prompt/context) and output (the desired completion) fields. While some variations exist, JSONL is the standard requirement for ingestion.

In InstructLab, the 'Taxonomy' is a hierarchical directory structure (YAML files) where users define the skills (tasks the model should perform) and knowledge (facts the model should know) they want to inject. Users submit contributions to the taxonomy, which are then used to generate synthetic data for training.

The primary role of a vector database (like Milvus, Chroma, or Elasticsearch with vector plugins) in a RAG architecture is to store high-dimensional vectors and perform efficient similarity searches (often using algorithms like HNSW for Approximate Nearest Neighbor) to retrieve relevant context based on the query's embedding.

Standard vector search (bi-encoder) is fast but sometimes misses fine-grained relevance. A Re-ranking step (using a Cross-Encoder) takes the top N results from the initial retrieval and scores them more accurately against the query. This significantly improves the quality of the context provided to the LLM.