Introduction to Prompt Engineering with Llama 3: Master instruction-tuned conversations and prompting techniques

Introduction

Traditional AI interactions require rigid command structures limiting natural communication. Developers struggle to extract optimal responses from language models without specialized knowledge. Manual experimentation with different prompting approaches consumes significant development time. Inconsistent model outputs complicate production deployment and user experience.

Llama 3:8B Chat transforms AI interactions through instruction-tuned conversational capabilities. It processes natural language queries generating contextually appropriate responses. The model adapts to different roles and output formats through system message configuration. Advanced prompting techniques enable creative writing, code generation, parametric queries, and chain-of-thought reasoning systematically.

Key Features

Llama 3:8B Chat provides comprehensive instruction-following capabilities through transformer architecture and conversational fine-tuning.

Instruction-Tuned Conversational Format

The model processes conversations through structured message arrays naturally. User and assistant roles organize multi-turn dialogues clearly. System messages establish behavioral guidelines and response constraints. Context maintains across conversation turns enabling coherent exchanges.

Instructions embedded in system prompts guide response characteristics. Output format specifications control structure and verbosity. Role-playing scenarios configure domain expertise and personality. Flexibility accommodates diverse application requirements without retraining.

Flexible System Message Configuration

System prompts define AI personality and behavioral constraints explicitly. Role definitions configure domain expertise and communication style. Output format instructions control structure and presentation. Constraint specifications prevent unwanted content or responses.

Configuration changes require no model retraining or fine-tuning. Different system prompts create specialized assistants instantly. Consistent interface simplifies production deployment across use cases. Applications maintain multiple configurations for different scenarios.

Multi-Turn Context Awareness

Conversation history accumulates enabling contextual understanding naturally. Previous exchanges inform current response generation logically. Reference resolution tracks entities across multiple turns. Coherent dialogues emerge from maintained context systematically.

Context window spans thousands of tokens accommodating lengthy conversations. Attention mechanisms weight relevant historical information appropriately. Applications build complex interactions through sequential exchanges. User experience improves through contextually aware responses.

Code Generation Across Languages

Programming language support spans Python, C++, JavaScript, and more. Syntax correctness maintained through training on code repositories. Documentation generation includes docstrings and inline comments. Type hints and best practices follow language-specific conventions.

Object-oriented programming patterns generate complete class structures. Function definitions include parameter validation and error handling. API development produces REST endpoints with proper routing. Cross-language consistency simplifies polyglot development workflows.

Parametric Template-Based Queries

Query templates enable flexible information retrieval patterns. Placeholder variables inject dynamic values into structured questions. Single templates generate diverse queries through parameter substitution. Consistent response formats simplify downstream processing.

Applications build reusable query libraries reducing development time. Template variables adapt to different domains without rewriting. Batch processing executes multiple parametric queries efficiently. Structured outputs facilitate automated analysis and reporting.

Chain-of-Thought Reasoning

Multi-step problem solving decomposes into explicit reasoning stages. Intermediate results feed into subsequent calculation steps. Transparent reasoning processes enable verification and debugging. Complex queries benefit from structured logical progressions.

Mathematical word problems solve through time-based calculations. Sequential reasoning builds on previous question answers naturally. Step-by-step explanations improve interpretability and trust. Educational applications leverage reasoning traces for learning.

Code Structure and Flow

The implementation follows systematic progression from environment setup through advanced reasoning demonstrations:

Stage 1: Library Imports and Dependencies

Essential Python libraries import enabling deep learning and interactive display. PyTorch provides tensor operations and GPU device management. Transformers pipeline enables high-level model inference abstraction. Time module measures performance and response generation latency. IPython Markdown renders formatted outputs improving notebook readability.

Code:

from time import time
import torch
import transformers
from transformers import AutoTokenizer, AutoModelForCausalLM
from IPython.display import display, Markdown

Import Breakdown:

• time: Captures timestamps for performance measurement and inference timing

• torch: PyTorch deep learning framework providing tensor operations and CUDA support

• transformers: Hugging Face library accessing pre-trained language models

• AutoTokenizer: Handles text tokenization and chat template formatting automatically

• AutoModelForCausalLM: Loads and manages causal language models for text generation

• display, Markdown: IPython utilities rendering formatted Markdown in Jupyter notebooks

Why These Libraries: PyTorch provides GPU acceleration and tensor computation. Transformers abstracts complex model loading and inference. IPython enables rich notebook output visualization.

Stage 2: Model Loading and Pipeline Creation

Llama 3:8B Chat model initializes through Hugging Face pipeline interface. Text generation task specifies causal language modeling objective. Model path points to pre-downloaded instruction-tuned weights. Device mapping automatically distributes model across available hardware. Float16 precision optimizes memory usage enabling larger models.

Code:

model_path = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"

llama_pipeline = transformers.pipeline(
    "text-generation",
    model=model_path,
    torch_dtype=torch.float16,
    device_map="auto",
)

Configuration Breakdown:

• model_path: Local filesystem path to instruction-tuned Llama 3 8B Chat weights

• "text-generation": Task specification for causal language modeling inference

• torch_dtype=torch.float16: Half-precision floating point reducing memory by 50%

• device_map="auto": Automatic GPU/CPU distribution optimizing hardware utilization

Technical Details: Pipeline abstraction handles tokenization, generation, and decoding automatically. Float16 precision maintains numerical stability while halving memory requirements. Automatic device mapping optimizes multi-GPU deployment when available.

Stage 3: Response Generation Function

Core function encapsulates complete inference workflow from prompt to formatted output. Parameters control generation behavior including temperature and output length. Message formatting applies Llama 3 chat template with special tokens. Termination conditions prevent infinite generation through stop token specifications. Performance timing tracks inference latency for optimization analysis.

Code:

def generate_llama_response(
    system_prompt,
    user_query,
    temperature=0.7,
    max_new_tokens=1024
):
    inference_start_time = time()
    
    formatted_query = "Question: " + user_query + " Answer:"
    
    conversation_messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": formatted_query},
    ]
    
    formatted_prompt = llama_pipeline.tokenizer.apply_chat_template(
        conversation_messages,
        tokenize=False,
        add_generation_prompt=True
    )
    
    termination_tokens = [
        llama_pipeline.tokenizer.eos_token_id,
        llama_pipeline.tokenizer.convert_tokens_to_ids("<|eot_id|>")
    ]
    
    generated_outputs = llama_pipeline(
        formatted_prompt,
        do_sample=True,
        top_p=0.9,
        temperature=temperature,
        eos_token_id=termination_tokens,
        max_new_tokens=max_new_tokens,
        return_full_text=False,
        pad_token_id=llama_pipeline.model.config.eos_token_id
    )
    
    generated_answer = generated_outputs[0]['generated_text']
    
    inference_end_time = time()
    total_inference_time = f"Total time: {round(inference_end_time - inference_start_time, 2)} sec."
    
    return formatted_query + " " + generated_answer + " " + total_inference_time

Function Component Breakdown:

Parameter Definitions:

• system_prompt: Defines AI role, personality, and behavioral constraints

• user_query: Actual question or request requiring AI response

• temperature: Controls generation randomness (0=deterministic, 1=creative)

• max_new_tokens: Maximum response length preventing excessive generation

Message Formatting:

• formatted_query: Adds "Question:" and "Answer:" structure prompting direct responses

• conversation_messages: List of role-content dictionaries following chat format

• System role establishes behavior before user query processing

Chat Template Application:

• apply_chat_template: Converts messages to Llama 3 prompt format with special tokens

• tokenize=False: Returns formatted string rather than token IDs

• add_generation_prompt: Appends assistant response initiation markers

Generation Parameters:

• do_sample=True: Enables probabilistic sampling instead of greedy decoding

• top_p=0.9: Nucleus sampling considering top 90% probability mass

• temperature: Adjusts logit distribution controlling randomness

• eos_token_id: Tokens triggering generation termination

• max_new_tokens: Hard limit on response length

• return_full_text=False: Returns only generated text excluding prompt

• pad_token_id: Token for sequence padding in batch processing

Performance Measurement:

• inference_start_time: Timestamp before generation begins

• inference_end_time: Timestamp after generation completes

• total_inference_time: Calculated latency formatted for display

Stage 4: Response Formatting Function

Utility function enhances visual presentation through color-coded sections. Keywords identify different response components systematically. HTML and Markdown formatting creates readable structured outputs. Color scheme distinguishes questions, answers, reasoning, and timing information.

Code:

def format_response_with_colors(text):
    keywords_and_colors = [
        ("Question", "blue"),
        ("Reasoning", "orange"),
        ("Answer", "green"),
        ("Total time", "gray")
    ]
    
    for keyword, color in keywords_and_colors:
        text = text.replace(
            f"{keyword}:",
            f"\n\n**<font color='{color}'>{keyword}:</font>**"
        )
    
    return text

Formatting Strategy:

• Keywords list defines section identifiers and corresponding colors

• Loop iterates through keywords applying HTML font color tags

• String replacement injects formatting around identified sections

• Newlines add vertical spacing improving visual separation

Color Scheme:

• Blue: Questions marking user queries

• Orange: Reasoning sections showing step-by-step logic

• Green: Answers containing model responses

• Gray: Timing information showing performance metrics

Stage 5: Simple Question and Answer Demonstrations

Factual question answering tests model knowledge across diverse domains. System prompt configures concise accurate responses without elaboration. Low temperature ensures deterministic outputs for factual queries. Examples span astronomy, geography, history, and cultural knowledge systematically.

System Prompt Configuration:

Code:

simple_qa_system_prompt = """
You are an AI assistant designed to answer factual questions accurately and concisely.
Please provide direct answers without unnecessary elaboration.
Focus on accuracy and clarity.
"""

Configuration Rationale:

• System prompt establishes factual assistant role explicitly

• Low temperature (0.1) minimizes randomness for consistency

• Limited tokens (256) enforce brevity matching prompt instructions

• Display pipeline renders formatted output with color coding

Example 1: Astronomy - Lunar Surface Temperature

Query: What is the surface temperature of the Moon?

Code:

response_astronomy = generate_llama_response(
    simple_qa_system_prompt,
    user_query="What is the surface temperature of the Moon?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_astronomy)))

Output:

Output: "The surface temperature of the Moon varies greatly depending on the time of day and the location on the Moon. The average temperature is around 107°C (225°F) during the day, while it can drop to as low as -173°C (-279°F) at night."

Inference Time: 3.97 seconds

Example 2: Geography - Area of France

Query: What is the total land area of France in square kilometers?

Code:

response_geography = generate_llama_response(
    simple_qa_system_prompt,
    user_query="What is the total land area of France in square kilometers?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_geography)))

Output:

Output: "The total land area of France is approximately 551,500 square kilometers."

Inference Time: 1.12 seconds

Example 3: European History - Thirty Years' War

Query: When did the Thirty Years' War take place and what were the main dates?

Code:

response_history_europe = generate_llama_response(
    simple_qa_system_prompt,
    user_query="When did the Thirty Years' War take place and what were the main dates?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_history_europe)))

Output:

Output: "The Thirty Years' War took place from 1618 to 1648. The main dates are:

1618: The war begins with the outbreak of the Bohemian Revolt
1620: The Catholic League is formed to counter the Protestant Union
1625: The Danish intervention begins
1635: The Swedish intervention begins
1645: The Treaty of Westphalia is signed, marking the beginning of the end of the war
1648: The Treaty of Münster is signed, officially ending the war"

Inference Time: 8.32 seconds

Example 4: Ancient Law - Graphē Paranómōn

Query: What was the graphē paranómōn (γραφὴ παρανόμων) in ancient Athens?

Code:

response_ancient_law = generate_llama_response(
    simple_qa_system_prompt,
    user_query="What was the graphē paranómōn (γραφὴ παρανόμων) in ancient Athens?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_ancient_law)))

Output:

Output: "The graphē paranómōn (γραφὴ παρανόμων) was a type of public prosecution in ancient Athens, where a citizen could bring a charge against another citizen for violating a law or decree."

Inference Time: 2.93 seconds

Example 5: Japanese History - Tokugawa Shogunate Succession

Query: Who succeeded Tokugawa Ieyasu as the shogun of Japan?

Code:

response_japan_history = generate_llama_response(
    simple_qa_system_prompt,
    user_query="Who succeeded Tokugawa Ieyasu as the shogun of Japan?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_japan_history)))

Output:

Output: "Tokugawa Hidetada succeeded Tokugawa Ieyasu as the shogun of Japan."

Inference Time: 1.62 seconds

Example 6: Ancient Chinese History - Han Dynasty

Query: Which Chinese dynasty ruled during the 1st century BC?

Code:

response_china_history = generate_llama_response(
    simple_qa_system_prompt,
    user_query="Which Chinese dynasty ruled during the 1st century BC?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_china_history)))

Output:

Output: "The Han Dynasty."

Inference Time: 0.37 seconds

Example 7: American History - First President

Query: Who was the first President of the United States?

Code:

response_us_history = generate_llama_response(
    simple_qa_system_prompt,
    user_query="Who was the first President of the United States?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_us_history)))

Output:

Output: "George Washington"

Inference Time: 0.24 seconds

Example 8: American Civil War Timeline

Query: When did the American Civil War take place?

Code:

response_civil_war = generate_llama_response(
    simple_qa_system_prompt,
    user_query="When did the American Civil War take place?",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_civil_war)))

Output:

Output: "The American Civil War took place from 1861 to 1865."

Inference Time: 1.12 seconds

Stage 6: Creative Writing and Poetry Generation

Poetic form generation demonstrates creative capabilities through structured constraints. System prompts specify exact formats including haiku and Shakespearean styles. Temperature remains low ensuring structural adherence to syllable counts. Topics range from sports achievements to humorous anachronistic scenarios.

Experiment 1: Haiku Format - Sports Achievement

Format: Haiku (5-7-5 syllable structure) Topic: Tennis legend Boris Becker

System Prompt:

haiku_system_prompt = """
You are an AI assistant specialized in writing poetry.
Please compose responses in haiku format (three lines with 5-7-5 syllable structure).
Focus on vivid imagery and emotional resonance.
"""

Code:

response_haiku_tennis = generate_llama_response(
    haiku_system_prompt,
    user_query="Write a haiku about tennis champion Boris Becker's powerful serve and Grand Slam victories",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_haiku_tennis)))

Output:

Racket's mighty roar
Becker's serve, a thunderbolt
Glory's sweet delight

Inference Time: 1.49 seconds

Experiment 2: Haiku Format - Literary Humor

Format: Haiku (5-7-5 syllable structure) Topic: William Shakespeare playing poker (anachronistic humor)

Code:

response_haiku_shakespeare = generate_llama_response(
    haiku_system_prompt,
    user_query="Write a haiku about William Shakespeare being terrible at playing poker",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_haiku_shakespeare)))

Output:

Output:
Bard's bluffing fails hard
Shakespeare's words can't hide his hand
Losses mount high

Inference Time: 1.64 seconds

Experiment 3: Shakespearean Style - Olympic Achievement

Format: Shakespearean-style poem (iambic pentameter, rhyming couplets)

Topic: Nadia Comăneci's perfect 10 at 1976 Montreal Olympics

System Prompt:

shakespearean_poetry_system_prompt = """
You are an AI assistant specialized in writing poetry.
Compose short poems with rhyme, in the style of William Shakespeare's sonnets.
Use iambic pentameter where possible and maintain an elevated, classical tone.
"""

Code:

response_shakespeare_olympics = generate_llama_response(
    shakespearean_poetry_system_prompt,
    user_query="Write a poem in Shakespeare's style about gymnast Nadia Comăneci scoring the first perfect 10 at the 1976 Montreal Olympics",
    temperature=0.1,
    max_new_tokens=512
)
display(Markdown(format_response_with_colors(response_shakespeare_olympics)))

Output:

Output:
Fair Nadia, thou dost shine so bright,
Like star that doth illume the Olympic night,
Thy form, a work of art, doth please the sight,
As thou dost execute each movement with all thy might.

Thy bars, a silver snake, dost thou ascend,
With ease and grace, as if 'twere thy best friend,
Thy vault, a perfect arc, dost thou design,
And in each twist, thy strength and skill doth shine.

And when thou dost dismount, with perfect score,
The crowd, in awe, doth rise, and with one voice, roar,
For thou hast achieved the feat, so rare and fine,
The first perfect ten, a mark of thy divine.

Oh, Nadia, thou hast made thy mark, so bold,
In annals of the Games, thy name shall be told,
For thou hast shown the world, thy skill so true,
And in thy triumph, our hearts are won anew.

Note: Iambic pentameter is used throughout the poem, with a rhyme scheme of ABAB CDCD EFEF GG.

Inference Time: 15.92 seconds

Stage 7: Python Code Generation

Programming assistance demonstrates multi-language capabilities starting with Python. System prompts configure language-specific conventions and best practices. Generated code includes proper documentation, type hints, and error handling. Complexity progresses from simple functions to complete object-oriented systems.

Python System Prompt:

python_code_system_prompt = """
You are an AI assistant specialized in writing clean, efficient Python code.
Provide well-structured code with appropriate function/class names and docstrings.
Include type hints where applicable.
"""

Python Example 1: Circle Area Calculation

Task: Write a function to calculate the area of a circle given radius r

Code:

response_python_circle = generate_llama_response(
    python_code_system_prompt,
    user_query="Write a Python function to calculate the area of a circle given radius r. Include the math import and proper documentation.",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_python_circle)))

Output:

Output:
import math

def calculate_circle_area(radius: float) -> float:
    """
    Calculate the area of a circle given the radius.
    
    Args:
        radius (float): The radius of the circle.
    
    Returns:
        float: The area of the circle.
    """
    return math.pi * (radius ** 2)

Inference Time: 10.65 seconds

Python Example 2: List Sorting Function

Task: Write a function to sort a list with options for ascending or descending order

Code:

response_python_sort = generate_llama_response(
    python_code_system_prompt,
    user_query="Write a Python function to sort a list with options for ascending or descending order",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_python_sort)))

Output:

Output:
def sort_list(lst: list, order: str = 'asc') -> list:
    """
    Sorts a list in ascending or descending order.
    
    Args:
        lst (list): The list to be sorted.
        order (str, optional): The order of sorting. Defaults to 'asc' for ascending order.
            Can be 'desc' for descending order.
    
    Returns:
        list: The sorted list.
    """
    if order == 'asc':
        return sorted(lst)
    elif order == 'desc':
        return sorted(lst, reverse=True)
    else:
        raise ValueError("Invalid order. It should be 'asc' or 'desc'.")

# Usage example
my_list = [4, 2, 9, 6, 5, 1, 3, 7, 8]
sorted_list = sort_list(my_list, 'asc')  # Sorts in ascending order
print(sorted_list)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Inference Time: 17.71 seconds

Python Example 3: PhoneBook Class (Object-Oriented Programming)

Task: Create a comprehensive PhoneBook class with CRUD operations

Requirements:

• Store contacts with fields: first_name, last_name, address, phone_number

• Implement methods: add_contact(), delete_contact(), search_contact(), sort_by_name()

• Use list to store contact dictionaries

• Include proper error handling and docstrings

Code:

response_python_phonebook = generate_llama_response(
    python_code_system_prompt,
    user_query="""Create a Python class called PhoneBook for managing contacts.
Requirements:
- Store contacts with fields: first_name, last_name, address, phone_number
- Implement methods: add_contact(), delete_contact(), search_contact(), sort_by_name()
- Use a list to store contact dictionaries
- Include proper error handling and docstrings
    """,
    temperature=0.1,
    max_new_tokens=1024
)
display(Markdown(format_response_with_colors(response_python_phonebook)))

Output:

Output:

class PhoneBook:
    """
    A class for managing contacts.
    
    Attributes:
        contacts (list): A list of dictionaries, where each dictionary represents a contact.
    """
    
    def __init__(self):
        """
        Initializes an empty phone book.
        """
        self.contacts = []
    
    def add_contact(self, first_name: str, last_name: str, address: str, phone_number: str) -> None:
        """
        Adds a new contact to the phone book.
        
        Args:
            first_name (str): The first name of the contact.
            last_name (str): The last name of the contact.
            address (str): The address of the contact.
            phone_number (str): The phone number of the contact.
        
        Raises:
            ValueError: If the contact already exists in the phone book.
        """
        contact = {
            "first_name": first_name,
            "last_name": last_name,
            "address": address,
            "phone_number": phone_number
        }
        if contact in self.contacts:
            raise ValueError("Contact already exists in the phone book.")
        self.contacts.append(contact)
    
    def delete_contact(self, first_name: str, last_name: str) -> None:
        """
        Deletes a contact from the phone book.
        
        Args:
            first_name (str): The first name of the contact to delete.
            last_name (str): The last name of the contact to delete.
        
        Raises:
            ValueError: If the contact does not exist in the phone book.
        """
        for contact in self.contacts:
            if contact["first_name"] == first_name and contact["last_name"] == last_name:
                self.contacts.remove(contact)
                return
        raise ValueError("Contact does not exist in the phone book.")
    
    def search_contact(self, first_name: str, last_name: str) -> dict:
        """
        Searches for a contact in the phone book.
        
        Args:
            first_name (str): The first name of the contact to search for.
            last_name (str): The last name of the contact to search for.
        
        Returns:
            dict: The contact dictionary if found, otherwise None.
        
        Raises:
            ValueError: If the contact does not exist in the phone book.
        """
        for contact in self.contacts:
            if contact["first_name"] == first_name and contact["last_name"] == last_name:
                return contact
        raise ValueError("Contact does not exist in the phone book.")
    
    def sort_by_name(self) -> None:
        """
        Sorts the contacts in the phone book by name.
        """
        self.contacts.sort(key=lambda x: (x["first_name"], x["last_name"]))
    
    def __str__(self) -> str:
        """
        Returns a string representation of the phone book.
        
        Returns:
            str: A string representation of the phone book.
        """
        result = ""
        for contact in self.contacts:
            result += f"Name: {contact['first_name']} {contact['last_name']}\n"
            result += f"Address: {contact['address']}\n"
            result += f"Phone Number: {contact['phone_number']}\n\n"
        return result

Inference Time: 51.75 seconds

Python Example 4: REST API Development

Task: Create a Flask REST API service with two endpoints

Requirements:

• /status (GET) - Returns server status

• /predict (POST) - Accepts JSON with fields: city, street, number; Returns JSON with field: price_estimate

• Include proper request validation and error handling

  
  

Code:

response_python_api = generate_llama_response(
    python_code_system_prompt,
    user_query="""Create a Flask REST API service with two endpoints:
1. /status (GET) - Returns server status
2. /predict (POST) - Accepts JSON with fields: city, street, number
   Returns JSON with field: price_estimate
Include proper request validation and error handling.
    """,
    temperature=0.1,
    max_new_tokens=512
)
display(Markdown(format_response_with_colors(response_python_api)))

Output:

Output:

from flask import Flask, jsonify, request
from flask_restful import Resource, Api
from marshmallow import Schema, fields
from marshmallow.exceptions import ValidationError

app = Flask(__name__)
api = Api(app)

class ServerStatus(Resource):
    def get(self):
        return {'status': 'Server is running'}

class PriceEstimate(Resource):
    class RequestSchema(Schema):
        city = fields.Str(required=True)
        street = fields.Str(required=True)
        number = fields.Int(required=True)
    
    def post(self):
        try:
            data = PriceEstimate.RequestSchema().load(request.json)
            # Your logic to estimate the price goes here
            price_estimate = 1000  # Replace with your actual logic
            return {'price_estimate': price_estimate}
        except ValidationError as err:
            return {'error': str(err)}, 400

api.add_resource(ServerStatus, '/status')
api.add_resource(PriceEstimate, '/predict')

if __name__ == '__main__':
    app.run(debug=True)

Inference Time: 27.36 seconds

Stage 8: C++ Code Generation

Cross-language capabilities extend to C++ demonstrating modern programming standards. System prompt configures C++11 standards and const correctness. Generated code includes proper headers and mathematical constants. Examples progress from simple calculations to STL algorithm usage.

C++ System Prompt Code:

cpp_code_system_prompt = """
You are an AI assistant specialized in writing clean, modern C++ code.
Use C++11 or later standards.
Include necessary headers and use const correctness.
"""

C++ Example 1: Circle Area Calculation

Task: Write a C++ function to calculate circle area using M_PI from cmath

Code:

response_cpp_circle = generate_llama_response(
    cpp_code_system_prompt,
    user_query="Write a C++ function to calculate the area of a circle given radius r. Use M_PI from cmath.",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_cpp_circle)))

Output:

Output:
#include <cmath>

double calculateCircleArea(double radius) {
    return M_PI * std::pow(radius, 2);
}

Inference Time: 6.45 seconds

C++ Example 2: Cylinder Volume Calculation

Task: Write a C++ function to calculate cylinder volume with radius r and height h

Code:

response_cpp_cylinder = generate_llama_response(
    cpp_code_system_prompt,
    user_query="Write a C++ function to calculate the volume of a cylinder with radius r and height h",
    temperature=0.1,
    max_new_tokens=512
)
display(Markdown(format_response_with_colors(response_cpp_cylinder)))

Output:

Output:
#include <cmath>

double cylinderVolume(double radius, double height) const {
    return M_PI * std::pow(radius, 2) * height;
}


Inference Time: 9.01 seconds

C++ Example 3: Vector Sorting

Task: Write a C++ function to sort std::vector in ascending or descending order

Code:

response_cpp_sort = generate_llama_response(
    cpp_code_system_prompt,
    user_query="Write a C++ function to sort a std::vector in ascending or descending order using std::sort",
    temperature=0.1,
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_cpp_sort)))

Output:

Output:
#include <algorithm>
#include <vector>

void sortVector(std::vector<int>& vec, bool isAscending) {
    if (isAscending) {
        std::sort(vec.begin(), vec.end());
    } else {
        std::sort(vec.begin(), vec.end(), std::greater<int>());
    }
}

// Usage example
int main() {
    std::vector<int> vec = {4, 2, 9, 6, 5, 1, 3, 7, 8};
    sortVector(vec, true);  // Sort in ascending order
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    
    sortVector(vec, false);  // Sort in descending order
    for (int i : vec) {
        std::cout << i << " ";
    }
}

Inference Time: 17.71 seconds

Stage 9: Parametric Template-Based Queries

Reusable query templates demonstrate flexible information retrieval patterns. Placeholder variables inject dynamic values into structured questions. Single template generates diverse queries across domains systematically. Consistent response formatting simplifies automated processing and analysis.

Parametric System Prompt:

parametric_query_system_prompt = """
You are an AI assistant designed to answer questions with specific parameters.
Format your answers with bullet points for clarity.
Provide concise, informative responses.
"""

Template Definition:

parametric_template = """
What are the {adjective} {number} {items} from {place}?
"""

Template Benefits: Code reusability across similar queries, consistent response structure enabling automation, easy experimentation with different parameters, rapid application development through templates, maintainable query libraries for production systems.

Example 1: French Cuisine - Best Foods

Parameters: adjective="best", number="3", items="traditional foods", place="France"

Code:

response_param_french_food = generate_llama_response(
    parametric_query_system_prompt,
    parametric_template.format(
        adjective="best",
        number="3",
        items="traditional foods",
        place="France"
    ),
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_param_french_food)))

Output:

Output:
"Here are the top 3 traditional French foods:

Coq au Vin: A classic dish made with chicken cooked in red wine, mushrooms, onions, and bacon, resulting in tender and flavorful meat.

Ratatouille: A vegetable stew originating from Provence, consisting of eggplant, zucchini, bell peppers, tomatoes, and garlic, often served as a side dish or used as a topping for bread.

Crème Brûlée: A rich dessert consisting of creamy custard base topped with a layer of caramelized sugar, typically served chilled and garnished with fresh fruit.

These dishes are not only delicious but also deeply rooted in French culinary tradition."

Inference Time: 9.67 seconds

Example 2: Italian Tourism - Top Attractions

Parameters: adjective="most iconic", number="five", items="tourist attractions", place="Italy"

Code:

response_param_italy_tourism = generate_llama_response(
    parametric_query_system_prompt,
    parametric_template.format(
        adjective="most iconic",
        number="five",
        items="tourist attractions",
        place="Italy"
    ),
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_param_italy_tourism)))

Output:

Output:
"Here are the top 5 most iconic tourist attractions in Italy:

Colosseum (Rome): This ancient amphitheater is one of Rome's most recognizable landmarks and a symbol of the city's rich history.

Leaning Tower of Pisa (Pisa): This famous tower is known for its unintended tilt, which has become a popular spot for photos and a must-see attraction in Italy.

Vatican City (Rome): The Vatican is home to numerous iconic landmarks, including St. Peter's Basilica, the Sistine Chapel, and the Vatican Museums, which attract millions of visitors each year.

Canals of Venice (Venice): Take a romantic gondola ride or stroll along the picturesque canals of Venice, exploring the city's stunning architecture and rich history.

Amalfi Coast (Campania): This stunning coastline is known for its crystal-clear waters, picturesque towns perched on cliffs, and stunning scenery, making it a popular destination for beachgoers and nature lovers."

Inference Time: 17.29 seconds

Example 3: Spanish Retirement - Affordable Locations

Parameters: adjective="most affordable", number="two", items="coastal cities to retire", place="Spain"

Code:

response_param_spain_retirement = generate_llama_response(
    parametric_query_system_prompt,
    parametric_template.format(
        adjective="most affordable",
        number="two",
        items="coastal cities to retire",
        place="Spain"
    ),
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_param_spain_retirement)))

Output:

Output: 

"Here are the most affordable coastal cities to retire from Spain:

Alicante: Located on the Costa Blanca, Alicante offers a warm Mediterranean climate, beautiful beaches, and a low cost of living. Rent: €400-€600 per month for a one-bedroom apartment.

Torrevieja: Also on the Costa Blanca, Torrevieja is a coastal town with a relaxed atmosphere and a low cost of living. Rent: €300-€500 per month for a one-bedroom apartment.

Some factors to consider when choosing a retirement location in Spain:

Affordability: Housing, food, and living costs are lower in these cities compared to larger cities like Barcelona or Madrid.

Healthcare: Spain has a well-regarded public healthcare system, and many cities have international healthcare facilities.

Language: While Spanish is the official language, many locals in Alicante and Torrevieja speak English, making it easier for expats to communicate and settle.

Culture: Both cities offer a rich cultural experience, with many festivals, events, and historical landmarks to explore."

Inference Time: 16.96 seconds

Example 4: Romanian Tourism - Hidden Gems

Parameters: adjective="less known but stunning", number="4", items="destinations to visit", place="Romania"

Code:

response_param_romania_hidden = generate_llama_response(
    parametric_query_system_prompt,
    parametric_template.format(
        adjective="less known but stunning",
        number="4",
        items="destinations to visit",
        place="Romania"
    ),
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_param_romania_hidden)))

Output:

Output: "Here are four less-known but stunning destinations to visit from Romania:

The Danube Delta: A UNESCO World Heritage Site, the Danube Delta is a unique and fragile ecosystem that is home to over 300 species of birds, as well as dolphins, turtles, and fish. Take a boat tour or hike through the delta's lush forests and wetlands to spot some of its incredible wildlife.

The Apuseni Mountains: Located in western Romania, the Apuseni Mountains are a hidden gem for hikers and nature lovers. The region is characterized by rugged peaks, deep valleys, and picturesque villages, and is home to a variety of flora and fauna.

The Black Sea Coast: While many visitors flock to the popular resort town of Mamaia, the Black Sea Coast has many other stunning destinations to offer. The charming town of Mangalia, for example, is known for its ancient ruins, beautiful beaches, and vibrant cultural scene.

The Maramureș Region: Located in northern Romania, the Maramureș Region is a culturally rich and picturesque area known for its traditional villages, wooden churches, and stunning natural scenery."

Inference Time: 17.68 seconds

Example 5: Shakespeare Literature - Best Comedies

Parameters: adjective="most beloved", number="3", items="comedies", place="William Shakespeare's complete works"

Code:

response_param_shakespeare = generate_llama_response(
    parametric_query_system_prompt,
    parametric_template.format(
        adjective="most beloved",
        number="3",
        items="comedies",
        place="William Shakespeare's complete works"
    ),
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_param_shakespeare)))

Output:

Output: "Here are the most beloved 3 comedies from William Shakespeare's complete works:

A Midsummer Night's Dream: A whimsical and enchanting play about love, magic, and mischief in the forest, featuring the iconic characters of Puck, Oberon, and the Mechanicals.

Twelfth Night: A witty and romantic comedy about love, identity, and mistaken identities, featuring the iconic characters of Viola, Orsino, and Malvolio.

As You Like It: A charming and lighthearted play about love, family, and social class, featuring the iconic characters of Rosalind, Orlando, and Jaques."

Inference Time: 11.42 seconds

Example 6: World War II History - Crucial Battles

Parameters: adjective="most decisive", number="5", items="battles", place="World War II"

Code:

response_param_wwii_battles = generate_llama_response(
    parametric_query_system_prompt,
    parametric_template.format(
        adjective="most decisive",
        number="5",
        items="battles",
        place="World War II"
    ),
    max_new_tokens=512
)
display(Markdown(format_response_with_colors(response_param_wwii_battles)))

Output:

Output: "Here are the 5 most decisive battles of World War II:

Battle of Stalingrad (August 1942 - February 1943): A turning point on the Eastern Front, where the Soviet Red Army defeated the German Sixth Army, marking a significant shift in the war's momentum.

Battle of El Alamein (October - November 1942): A decisive battle in North Africa, where British forces under General Bernard Montgomery defeated the German and Italian armies, forcing them to retreat and ultimately leading to the Allied victory in the region.

Battle of Midway (June 1942): A naval battle in the Pacific, where the United States defeated Japan, preventing a potential Japanese invasion of the Hawaiian Islands and turning the tide of the war in the Pacific.

Battle of Kursk (July - August 1943): A massive tank battle on the Eastern Front, where the Soviet Red Army defeated the German Wehrmacht, marking a significant defeat for Germany and setting the stage for the Soviet advance into Eastern Europe.

Battle of Normandy (D-Day, June 6, 1944): A pivotal battle in Western Europe, where Allied forces launched a massive invasion of Nazi-occupied France, marking a significant turning point in the war and paving the way for the liberation of Western Europe."

Inference Time: 20.46 seconds

Stage 10: Chain-of-Thought Reasoning

Complex problem solving decomposes through explicit reasoning steps systematically. System prompts explicitly request step-by-step explanations and logical progressions. Multi-step queries build on previous answers demonstrating sequential dependency. Mathematical word problems test logical deduction and temporal reasoning capabilities.

Chain-of-Thought System Prompt:

chain_of_thought_system_prompt = """
You are an AI assistant designed to answer multi-step questions using chain-of-thought reasoning.
Think step by step. Use the answer from the first question as input for subsequent questions.
Show your reasoning process clearly.
"""

Reasoning Benefits: Transparent problem-solving processes enabling verification, intermediate result validation improving accuracy, improved performance on complex queries requiring multiple steps, educational value showing logical progressions, debugging capability through visible reasoning traces.

Experiment 1: Sequential Reasoning - Tourist Recommendations

Task: Two-step query where second answer depends on first

• Question 1: What is the best city in France for tourists?

• Question 2: What are the top 3 attractions in that city?

Template Definition:

two_step_query_template = """
Question one: What is the best city in {country} for tourists?
Question two: What are the top {number} attractions in the city identified in question one?
Answer:
"""

Code:

response_cot_france_tourism = generate_llama_response(
    chain_of_thought_system_prompt,
    two_step_query_template.format(
        number="3",
        country="France"
    ),
    max_new_tokens=256
)
display(Markdown(format_response_with_colors(response_cot_france_tourism)))

Output:

Output: "I'll answer the questions step by step!

Question 1: What is the best city in France for tourists?

To answer this, I'll consider popular tourist destinations in France. Paris is often considered one of the most popular cities for tourists. However, I'll also consider other options like Lyon, Bordeaux, and Nice.

After considering various factors like cultural attractions, historical landmarks, and overall tourist experience, I'll choose... Paris as the best city in France for tourists!

Reasoning: Paris is known for its iconic landmarks like the Eiffel Tower, Notre-Dame Cathedral, and the Louvre Museum. It's also famous for its romantic atmosphere, fashion, and cuisine. The city has a wide range of accommodations, restaurants, and activities suitable for all types of tourists.

Question 2: What are the top 3 attractions in the city identified in question one?

Now that we've identified Paris as the best city in France for tourists, let's focus on the top attractions in Paris.

To answer this, I'll consider popular attractions in Paris, including museums, landmarks, and cultural events. After considering various options, I'll choose...

Top 3 attractions in Paris:

The Eiffel Tower..."

Inference Time: 17.72 seconds

Experiment 2: Mathematical Reasoning - The Swallow and Train Problem

Classic Puzzle: Mathematical word problem requiring logical thinking and time-based calculation

Problem Setup:

• Train travels from Bucharest to Ploiești (60 km distance) at 60 km/h

• Swallow flies at 90 km/h between approaching train and Ploiești

• Swallow flies continuously back and forth until train arrives

• Question: How many kilometers does swallow fly in total?

Solution Approach:

• Time-based calculation (simpler than distance tracking)

• Train takes 1 hour to travel 60 km (60 km ÷ 60 km/h = 1 hour)

• Swallow flies continuously for 1 hour at 90 km/h

• Total distance = 90 km × 1 hour = 90 km

System Prompt with Problem Context:

math_problem_system_prompt = """
You are a mathematics professor - knowledgeable and clear in explanations.

Background: A train traveling from Bucharest to Ploiești (60 km distance) travels at 60 km/h.
The train starts in Bucharest and travels directly to Ploiești in one direction only.

A swallow, flying at 90 km/h, starts at Ploiești and flies toward the approaching train.
When the swallow reaches the train, it immediately turns around and flies back toward Ploiești.
Upon reaching Ploiești, it turns around again toward the train.
The swallow continues flying back and forth between the moving train and Ploiești
until the train finally reaches Ploiești.

Reasoning: Think step by step. Explain your reasoning clearly.

Question: {question}
Answer:
"""

Code:

complex_reasoning_start = time()

response_math_swallow_problem = generate_llama_response(
    math_problem_system_prompt,
    user_query="How many kilometers in total will the swallow fly?",
    temperature=0.1,
    max_new_tokens=512
)

total_complex_reasoning_time = round(time() - complex_reasoning_start, 2)

display(Markdown(format_response_with_colors(f"{response_math_swallow_problem}\n\nTotal execution time: {total_complex_reasoning_time} sec.")))

Output:

Output: "Let's break this problem down step by step.

The train travels from Bucharest to Ploiești at a constant speed of 60 km/h. Since the distance is 60 km, the time it takes for the train to reach Ploiești is: Time = Distance / Speed = 60 km / 60 km/h = 1 hour

The swallow starts at Ploiești and flies towards the approaching train. Since the train is moving at 60 km/h, the relative speed between the swallow and the train is: Relative speed = Swallow's speed + Train's speed = 90 km/h + 60 km/h = 150 km/h

The distance between the swallow and the train is decreasing at a rate of 150 km/h. When the swallow reaches the train, it will have covered a distance of: Distance = Relative speed × Time = 150 km/h × 1 hour = 150 km

The swallow turns around and flies back to Ploiești. Since it's flying at 90 km/h, it will take: Time = Distance / Speed = 150 km / 90 km/h = 1.67 hours (approximately)

The swallow reaches Ploiești and turns around again. It will now fly towards the train, which is still moving at 60 km/h. The relative speed between the swallow and the train is still 150 km/h. The swallow will cover the same distance of 150 km before reaching the train again.

The swallow continues flying back and forth between the train and Ploiești until the train reaches Ploiești. Since the train takes 1 hour to reach Ploiești, the swallow will make 2 more round trips (since it starts and ends at Ploiești).

In total, the swallow flies 4 round trips: 2 round trips before the train reaches Ploiești, and 2 round trips after the train reaches Ploiești.

The total distance flown by the swallow is: Total distance = 4 × (150 km + 150 km) = 4 × 300 km = 1200 km

Therefore, the swallow will fly a total of 1200 kilometers."

Inference Time: 33.24 seconds Total Execution Time: 33.24 seconds

Simpler Solution: The time-based approach yields the correct answer more directly:

• Train takes 1 hour to travel 60 km

• Swallow flies continuously for this entire 1 hour period

• Swallow speed: 90 km/h

• Total swallow distance: 90 km/h × 1 hour = 90 km

Reasoning Demonstration: Multi-step mathematical decomposition shown clearly. Formulas applied explicitly with unit tracking. Intermediate calculations performed systematically. Complex problem tackled through logical progression. Educational value in showing complete thought process even when alternative approaches exist.

Full code is available at:

Prompt Engineering with Llama 3 - A Beginners Guide.pdf

Download PDF • 422KB

Use Cases & Applications

Intelligent Chatbots and Virtual Assistants

Customer service platforms need AI capable of natural conversations. Manual response crafting for every query proves impractical at scale. Instruction-tuned models generate contextually appropriate responses automatically. System prompts configure personality, tone, and domain expertise dynamically.

Automated Content Generation

Marketing teams require diverse content across multiple formats. Writers spend hours creating poetry, articles, and creative pieces manually. Language models generate creative content from simple prompts efficiently. Temperature controls balance creativity with consistency based on requirements.

Code Development and Review

Software developers need intelligent coding assistance across languages. Writing boilerplate code and documentation consumes valuable development time. Llama 3 generates syntactically correct code with proper documentation. Multi-language support covers Python, C++, JavaScript, and more comprehensively.

Educational and Training Systems

Educational platforms need adaptive tutoring across subject domains. One-size-fits-all explanations fail to meet diverse learning needs. AI tutors adjust explanation depth and style based on context. Step-by-step reasoning helps students understand complex problem-solving processes.

Research and Analysis

Researchers need structured information retrieval and synthesis capabilities. Manual literature review and fact-checking consume substantial research time. Parametric prompting enables flexible queries across knowledge domains. Chain-of-thought reasoning handles multi-step analytical questions systematically.

System Overview

Llama 3:8B Chat operates through instruction-following conversational architecture processing natural language. The system accepts structured messages with role-based formatting distinguishing user queries from AI responses. System messages define behavioral constraints and output characteristics before processing begins. The model generates responses using causal language modeling predicting next tokens probabilistically.

The architecture implements transformer-based attention mechanisms enabling contextual understanding. Self-attention layers process input sequences capturing relationships between tokens. Feed-forward networks transform representations generating meaningful outputs. Position encodings maintain sequence order critical for language understanding.

Model initialization uses Hugging Face Transformers pipeline abstracting complex preprocessing. GPU acceleration through CUDA enables real-time inference at production scale. Float16 precision reduces memory requirements without sacrificing numerical stability. Chat templates format conversations with special tokens ensuring optimal model performance.

Six core capabilities demonstrate through systematic experiments progressively. Simple question answering tests factual knowledge accuracy. Creative writing explores poetry generation across different styles. Code generation validates multi-language programming support. Parametric prompting demonstrates flexible template-based queries. Chain-of-thought reasoning evaluates complex multi-step problem-solving capabilities systematically.

---

Who Can Benefit From This

Startup Founders

• Conversational AI Platform Developers - building chatbots and virtual assistants with natural language understanding

• Content Generation Service Providers - creating automated writing tools for marketing and creative industries

• EdTech Platform Creators - developing intelligent tutoring systems with adaptive explanations

• Developer Tools Entrepreneurs - building AI-powered coding assistants and documentation generators

• Research Platform Builders - creating knowledge synthesis tools for academic and business intelligence

Developers

• Full-Stack Engineers - integrating language models into applications without deep ML expertise

• Backend Developers - building API services powered by large language models

• DevOps Engineers - optimizing model deployment and inference infrastructure

• Mobile App Developers - creating on-device or cloud-based AI assistants

• ML Engineers - fine-tuning instruction-following models for specialized domains

Students

• Computer Science Students - learning modern NLP through practical language model implementations

• AI/ML Students - understanding transformer architectures and attention mechanisms

• Data Science Students - exploring prompt engineering and model behavior optimization

• Software Engineering Students - building portfolio projects demonstrating AI capabilities

• Research Students - experimenting with instruction-tuning and model evaluation methodologies

Business Owners

• Customer Service Operations - automating support interactions through intelligent chatbots

• Content Marketing Agencies - scaling content production across multiple formats and channels

• Software Development Firms - accelerating coding through AI-assisted development tools

• Educational Institutions - providing personalized tutoring at scale through AI systems

• Research Organizations - synthesizing information and generating insights from large corpora

Corporate Professionals

• Product Managers - evaluating language model capabilities for feature development

• Technical Writers - generating documentation and technical content efficiently

• Data Scientists - applying language models to business problems requiring text understanding

• Business Analysts - extracting insights from unstructured text data at scale

• Innovation Teams - prototyping AI-powered solutions for organizational challenges

---

How Codersarts Can Help

Codersarts specializes in developing language model applications and prompt engineering solutions. Our expertise in natural language processing, transformer architectures, and production deployment positions us as your ideal partner for instruction-tuned AI development.

Custom Development Services

Our team works closely with your organization to understand language model application requirements. We develop customized prompting strategies matching your domain and use cases. Solutions maintain high accuracy while delivering real-time performance through optimized deployment.

End-to-End Implementation

We provide comprehensive implementation covering every aspect:

• Model Integration - Llama, GPT, Claude, and other language model deployment

• Prompt Engineering - system message design and template development

• Response Optimization - temperature tuning and output format control

• GPU Acceleration - CUDA optimization and efficient memory management

• API Development - RESTful interfaces for language model service integration

• Batch Processing - high-volume query pipelines for large-scale applications

• Fine-Tuning - domain-specific model adaptation through instruction datasets

• Evaluation Systems - response quality measurement and continuous improvement

Rapid Prototyping

For organizations evaluating language model capabilities, we offer rapid prototype development. Within two to three weeks, we demonstrate working systems processing your actual use cases. This showcases accuracy, response quality, and integration feasibility.

Industry-Specific Customization

Different industries require unique prompting approaches. We customize implementations for your specific domain:

• Healthcare - clinical documentation and patient communication with HIPAA compliance

• Finance - automated report generation and financial analysis with regulatory adherence

• Legal - contract analysis and legal research with precision requirements

• Education - adaptive tutoring and content generation with pedagogical principles

• Technology - code generation and documentation with engineering best practices

Ongoing Support and Enhancement

Language model applications benefit from continuous improvement. We provide ongoing support services:

• Model Updates - upgrading to newer models as they release

• Performance Optimization - reducing inference latency and memory usage

• Accuracy Improvement - refining prompts and fine-tuning on domain data

• Feature Enhancement - adding new capabilities like multi-turn conversations and context management

• Scalability Support - handling increased usage through infrastructure optimization

• Quality Monitoring - tracking output quality and implementing feedback loops

What We Offer

• Complete AI Applications - production-ready language model systems with user interfaces

• Custom Prompt Libraries - domain-specific templates and system message configurations

• API Services - language model inference as a service for easy integration

• Training Programs - comprehensive workshops teaching prompt engineering and model deployment

• Consulting Services - architecture design and technical guidance for AI initiatives

• Quality Assurance - evaluation frameworks ensuring consistent model performance

Call to Action

Ready to transform your applications with instruction-tuned language models?

Codersarts is here to help you implement prompt engineering solutions that generate natural language responses, creative content, and intelligent code automatically. Whether you are building chatbots, content generation systems, or AI-powered development tools, we have the expertise to deliver language models that understand your requirements.

Get Started Today

Schedule a Consultation - book a 30-minute discovery call to discuss your language model needs and explore prompting strategies.

Request a Custom Demo - see prompt engineering in action with a personalized demonstration using your actual use cases and domain.

Email: contact@codersarts.com

Contact Us

Special Offer - mention this blog post to receive 15% discount on your first language model project.

Transform natural language into intelligent applications. Partner with Codersarts to build AI systems that understand instructions, generate creative content, and solve complex problems systematically. Contact us today and take the first step toward language models that comprehend, reason, and communicate naturally.