🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

<span>Tutorial</span>

<span>Advanced</span>

<span>⏱ 45 min read</span>

<span>© Gate of AI 2026-06-16</span>

Learn how to fine-tune large language models (LLMs) to enhance communication capabilities in specialized domains, such as homeless shelters, using modern AI tools and techniques like LoRA.

Prerequisites

• Python 3.10+



• OpenAI API key (latest version)



• Familiarity with machine learning concepts

What We're Building

In this tutorial, we will embark on a journey to fine-tune a large language model (LLM) to cater to the specific communication needs of homeless shelters. By leveraging a bespoke dataset compiled from the Youth Spirit Artworks (YSA) Tiny House Empowerment Village website, we aim to create a model that can effectively assist in the nuances of communication required in such environments.

The finished project will result in a model capable of generating contextually relevant and empathetic responses to inquiries typical within the homeless shelter community. This involves structuring data into a standardized question-and-answer format to enhance the training process, ensuring the model's outputs are aligned with the communication style and needs of the target audience.

Setup and Installation

To begin, we need to set up our development environment with the necessary tools and libraries for model fine-tuning. We'll be using Python along with the OpenAI library to interact with the LLMs.

pip install openai pandas numpy

Additionally, you'll need to configure environment variables to securely store your API keys. This ensures that sensitive information is not hardcoded into your scripts.

  

  

  .env file





OPENAI_API_KEY=your_openai_api_key


  

Step 1: Data Collection and Preparation

The first step in fine-tuning our model involves collecting and preparing the data. The dataset, sourced from the YSA Tiny House Empowerment Village, needs to be organized into a structured Q&A format to facilitate effective training.

import pandas as pd



  

  

  Load the dataset





data = pd.read_csv('ysa_dataset.csv')




  

  

  Example of structuring data





qa_pairs = []


for index, row in data.iterrows():


    question = row['question']


    answer = row['answer']


    qa_pairs.append({'prompt': question, 'completion': answer})




  

  

  Save the structured data for further processing





structured_data = pd.DataFrame(qa_pairs)


structured_data.to_csv('structured_qa.csv', index=False)


  

Here, we load the dataset and iterate over each entry to extract questions and their corresponding answers. These pairs are then stored in a new CSV file, which will serve as the input for our model training process.

Step 2: Setting Up the Fine-Tuning Environment

With our data prepared, the next step is to set up the environment for fine-tuning. This involves configuring the OpenAI client and preparing our dataset for training.

from openai import OpenAI



  

  

  Initialize the OpenAI client





client = OpenAI(api_key='your_openai_api_key')




  

  

  Prepare the dataset for fine-tuning





def prepare_fine_tuning_data(file_path):


    with open(file_path, 'r') as f:


        lines = f.readlines()


    return [{'prompt': line.split(',')[0], 'completion': line.split(',')[1]} for line in lines]




  

  

  Load the prepared data





training_data = prepare_fine_tuning_data('structured_qa.csv')


  

We initialize the OpenAI client using the API key and prepare the data by reading the structured CSV file. Each line is converted into a dictionary format expected by the OpenAI API for fine-tuning.

Step 3: Fine-Tuning the Model

Now, we proceed to the core of this tutorial—fine-tuning the model. This step involves sending our prepared data to the OpenAI API to adjust the model's parameters for our specific use case. We will also explore using LoRA fine-tuning, a cost-effective method that allows fine-tuning on a single GPU.

response = client.chat.completions.create(


    model="gpt-4o",


    messages=[{"role": "system", "content": "You are a helpful assistant for a homeless shelter."}] + training_data,


    max_tokens=1500


)



  

  

  Check the response





print(response)


  

In this code block, we use the chat.completions.create method to fine-tune the model. The training data is appended to a system message that sets the context of the assistant. The response from the API will help us understand how well the model has adapted to the new data.

⚠️ Common Mistake: Ensure that the data format strictly matches the input requirements of the OpenAI API. Mismatched formats can lead to errors during fine-tuning.

Testing Your Implementation

After fine-tuning, it's crucial to test the model to ensure it behaves as expected. This involves running a series of test prompts through the model and verifying the responses.

test_prompts = [


    "What services are available at the shelter?",


    "How can I volunteer?"


]



for prompt in test_prompts:


    response = client.chat.completions.create(


        model="gpt-4o",


        messages=[{"role": "user", "content": prompt}]


    )


    print(f"Prompt: {prompt}\nResponse: {response['choices'][0]['message']['content']}\n")


  

In this testing phase, we pass predefined prompts to the model and examine the responses to ensure they are relevant and contextually appropriate for a homeless shelter environment.

What to Build Next

• Integrate the fine-tuned model into a chatbot application for real-time assistance.



• Expand the dataset to include more diverse scenarios and improve the model's robustness.



• Explore multi-modal interactions by incorporating voice and text inputs to broaden accessibility.

In the context of the GCC and Middle East, such AI-driven solutions can significantly enhance community support systems, aligning with initiatives like Saudi Vision 2030 and the UAE National Strategy for AI, which aim to integrate advanced technologies into public services.