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!

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.

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:

1. PromptBuilder: Prepares the prompt for the language model.
2. OpenAIGenerator: Sends the prompt to an LLM (like GPT-4) and gets the response.

Here's a simple diagram of what we'll build:

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.

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:

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.

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:

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:

Now let's put everything together into a Haystack pipeline and see it in action.

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.

With our pipeline assembled, let's run it and see the results!

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:

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.

In this first lesson, we've explored the basics of Haystack and learned how to build a simple pipeline for natural language translation. We saw how to use the PromptBuilder to create prompts and the OpenAIGenerator to connect with a language model. This hands-on experience with Haystack's core concepts will make it much easier to build more advanced pipelines in the upcoming lessons.

As we move forward in our course path, we'll shift our focus from natural language to code translation. We'll build on these pipeline concepts and expand our knowledge of Haystack to create a powerful code translation system. Feel free to experiment with different inputs or prompt templates to deepen your understanding of how Haystack works.

In the meanwhile, it's time to put into practice everything you learned today. Happy coding!