Exploring Haystack Basics | CodeSignal Learn

Exploring Haystack Basics | CodeSignal Learn

Introduction

Hello and welcome! I'm excited to have you join us for the very first lesson of our course path, Building a Smart Code Translator with Haystack, FastAPI, and Gradio . In this journey, we'll learn how to create an intelligent application that can translate code from one programming language to another. This course path is divided into three main parts. In this first course, titled " Laying the Foundations for Code Translation with Haystack ", we'll explore Haystack, a powerful framework for building applications powered by large language models (LLMs), and establish a solid pipeline for code translation. Next, we'll use FastAPI to create a backend for our translator. Finally, we'll build an interactive user interface with Gradio . In this initial lesson, we'll kickoff by introducing Haystack. We'll get hands-on experience with its basic building blocks and see how it can help us create smart, flexible pipelines for language tasks. Let's get started!

What Is Haystack and Why Use It?

Haystack is an open-source Python framework designed to help developers build applications powered by large language models (LLMs), like those from OpenAI. It's especially good at tasks that involve understanding, generating, or transforming text — such as answering questions, searching documents, or, as we'll see later, translating code. Some reasons why we use Haystack: Modular Pipelines: We can connect different components (like prompt builders and LLMs) in a flexible way. Prompt Templating: It helps us create and manage prompts for LLMs easily. Production-Ready: Haystack is designed for real-world applications, so it's reliable and scalable. In this lesson, we'll use Haystack to build a simple pipeline that translates English text into French. This will help us understand the basics before we move on to code translation in the next lessons.

Understanding Haystack Pipelines

Let's talk about one of the most important concepts in Haystack: the Pipeline . A pipeline in Haystack is like an assembly line. Each component in the pipeline does a specific job, and the output of one component becomes the input for the next. This makes it easy to build complex workflows by connecting simple building blocks. For our first example, our pipeline in this lesson will have two main components: PromptBuilder: Prepares the prompt for the language model. OpenAIGenerator: Sends the prompt to an LLM (like GPT-4) and gets the response. Here's a simple diagram of what we'll build: Input Text \to PromptBuilder \to OpenAIGenerator \to Output (French Translation) By the end of this lesson, we'll have a working pipeline that translates a sentence from English to French using these components. This modular approach is what makes Haystack so powerful — you can swap components or add new ones to create increasingly sophisticated applications.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Building a Prompt with PromptBuilder

Let's start by looking at how we can create a prompt for our language model using Haystack's PromptBuilder. Haystack uses Jinja2 templates for prompt creation. Jinja2 is a powerful templating engine for Python that lets you define placeholders and logic inside your text templates. This makes it easy to create dynamic prompts that can adapt to different inputs: from haystack.components.builders import PromptBuilder # Create a prompt template for translation prompt_builder = PromptBuilder( template="Translate the following text to French: {{text}}", # Jinja2 template with a variable required_variables=["text"] # The variable that must be provided ) In this snippet: We import PromptBuilder from Haystack. We create a prompt template using Jinja2 syntax. The {{text}} part is a Jinja2 placeholder that will be replaced with the actual sentence we want to translate. The required_variables argument tells Haystack which variables must be provided when using this template. This approach makes it easy to reuse the same prompt structure for different inputs. For example, we could translate multiple sentences without rewriting the prompt each time — we just provide different values for the text variable.

Connecting to a Large Language Model with Generators

Now that we have a prompt, we need a way to send it to a language model and get a response. That's where Generators come into play. Specifically, we'll be using the OpenAIGenerator class throughout the course: from haystack.components.generators.openai import OpenAIGenerator # Initialize the OpenAIGenerator with a specific model generator = OpenAIGenerator(model="gpt-4o-mini") # Using a smaller, efficient model What's happening here? We import OpenAIGenerator from Haystack. We create an instance of the generator, specifying which OpenAI model to use (in this case, "gpt-4o-mini"). This component will take our prompt and ask the language model to generate a response — in our case, a French translation. The beauty of this approach is that you can easily switch to different models (like GPT-4o or another provider's model) by changing just this one line. Note: Under the hood, OpenAIGenerator uses your OpenAI API key to authenticate requests to the OpenAI service. By default, it looks for the OPENAI_API_KEY environment variable. Make sure you have set this environment variable in your environment before running the code, for example: export OPENAI_API_KEY=your-openai-api-key

Creating the Translation Pipeline

Now let's put everything together into a Haystack pipeline and see it in action. from haystack import Pipeline # Build the pipeline pipeline = Pipeline() # Create an empty pipeline pipeline.add_component("prompt_builder", prompt_builder) # Add our prompt component pipeline.add_component("llm", generator) # Add our language model component pipeline.connect("prompt_builder.prompt", "llm.prompt") # Connect the components Here: We create a new Pipeline object. We add our components to the pipeline using pipeline.add_component(), giving each one a name. We connect the output of the prompt builder to the input of the language model via pipeline.connect() . We use prompt_builder.prompt and llm.prompt because we're explicitly connecting the prompt output of the prompt builder to the prompt input of the language model. This is useful when components have multiple input/output fields. Think of this as creating a circuit: we're defining how data should flow through our system. The connection step is crucial — we're telling Haystack that the prompt output from our prompt_builder should be sent as the prompt input to our llm component.

Running the Translation Pipeline

With our pipeline assembled, let's run it and see the results! # Provide input data input_data = {"text": "Hello, how are you?"} # The English text we want to translate # Run the pipeline result = pipeline.run(data=input_data) # Execute the pipeline with our input print("Pipeline output:", result["llm"]["replies"][0]) # Display the translation In this snippet, we provide our input data as a dictionary. The key "text" matches the variable we defined in our prompt template. We then call pipeline.run() with our input data to execute the pipeline and print the result. When you run this code, you'll see something like: Pipeline output: Bonjour, comment allez-vous? Notice how Haystack handles all the complex interactions with the language model for us. We don't need to worry about API calls, authentication, or formatting — we just define what we want, and Haystack takes care of the rest.

Python

from haystack.components.builders import PromptBuilder

# Create a prompt template for translation
prompt_builder = PromptBuilder(
    template="Translate the following text to French: {{text}}",  # Jinja2 template with a variable
    required_variables=["text"]  # The variable that must be provided
)

Python

from haystack.components.generators.openai import OpenAIGenerator

# Initialize the OpenAIGenerator with a specific model
generator = OpenAIGenerator(model="gpt-4o-mini")  # Using a smaller, efficient model

Python

from haystack import Pipeline

# Build the pipeline
pipeline = Pipeline()  # Create an empty pipeline
pipeline.add_component("prompt_builder", prompt_builder)  # Add our prompt component
pipeline.add_component("llm", generator)  # Add our language model component
pipeline.connect("prompt_builder.prompt", "llm.prompt")  # Connect the components

Python

# Provide input data
input_data = {"text": "Hello, how are you?"}  # The English text we want to translate

# Run the pipeline
result = pipeline.run(data=input_data)  # Execute the pipeline with our input
print("Pipeline output:", result["llm"]["replies"][0])  # Display the translation