Welcome to the Llama 2 Developer Guide for AWS integration! Llama 2 is a pre-trained generative text model, and these Amazon Machine Images are fully optimized for developers utilizing advanced text generation with OpenAI API compatibility. Let's dive in and unlock the full potential of Llama 2 within your AWS environment.

Video Guide

Prerequisites

Before you get started with the Llama 2 AMI, ensure you have the following prerequisites:

  • Basic knowledge of AWS services, including EC2 instances and CloudFormation.
  • An active AWS account with appropriate permissions.
  • Enough vCPU limit to create g4dn type instances. If you encounter a vCPU quota error when launching the stack, follow https://meetrix.io/blogs/increase-aws-vcpu-quota/ to increase your vCPU limit.

Launching the AMI

Step 1: Find and Select "Llama 2" AMI

  1. Log in to your AWS Management Console.
  2. Follow the provided links to access the "Llama 2" product you wish to set up:
    1. LLaMa 2 Meta AI 70B: OpenAI API Compatible AMI
    2. LLaMa 2 Meta AI 7B: OpenAI API Compatible AMI

Step 2: Initial Setup & Configuration

  1. Click the "Continue to Subscribe" button.
  2. After subscribing, you will need to accept the terms and conditions. Click on "Accept Terms" to proceed.
  3. Please wait for a few minutes while the processing takes place. Once it's completed, select your preferred region.
  4. From the "Choose Action" dropdown menu, select "Launch CloudFormation" and click "Launch" button.

Create CloudFormation Stack

Step 1: Create stack

  1. Ensure the "Template is ready" radio button is selected under "Prepare template".
  2. Click "Next".

Step 2: Specify stack options

Provide the necessary parameters for your Llama 2 deployment. These settings define how your instance will be configured.

Parameter Description
Stack name A unique name for your CloudFormation stack.
Admin Email The email address used for SSL generation.
DeploymentName A name for your deployment, of your choice.
LlamaDomainName Your public domain name. Llama 2 will automatically try to set up SSL if this domain is hosted on Route 53. If unsuccessful, you will need to set up SSL manually.
LlamaInstanceType The EC2 instance type. Recommended: g4dn.xlarge for 7B/13B, g4dn.12xlarge for 70B.
keyName The name of your preferred EC2 key pair for SSH access.
SSHLocation The IP address range for SSH access. Defaults to 0.0.0.0/0 (open to all). For better security, restrict this to your IP.
SubnetCidrBlock The CIDR block for the subnet. Defaults to 10.0.0.0/24.
VpcCidrBlock The CIDR block for the VPC. Defaults to 10.0.0.0/16.

Click "Next".

Step 3: Configure stack options

  1. Under "Stack failure options," select "Roll back all stack resources".
  2. Click "Next".

Step 4: Review

  1. Review and verify the details you've entered.
  2. CloudFormation stack parameters for Llama 2
  3. Tick the box that says, "I acknowledge that AWS CloudFormation might create IAM resources with custom names".
  4. Acknowledging IAM resource creation in CloudFormation
  5. Click "Submit".

Afterward, you'll be directed to the CloudFormation stacks page.

Please wait for 5-10 minutes until the stack has been successfully created.

Llama 2 CloudFormation stack creation complete

Update DNS

Step 1: Copy IP Address

Copy the public IP labeled "PublicIp" in the "Outputs" tab.

Copying the PublicIp from CloudFormation Outputs tab

Step 2: Update DNS

  1. Go to AWS Route 53 and navigate to "Hosted Zones".
  2. Select the provided domain and click "Edit record".
  3. Editing a DNS record in AWS Route 53 for Llama 2
  4. Paste the copied "PublicIp" into the "value" textbox.
  5. Click "Save".

Access Llama

You can access the Llama 2 application through the "DashboardUrl" provided in the "Outputs" tab.

DashboardUrl in CloudFormation Outputs tab

Note

If you encounter a "502 Bad Gateway" error, please wait for about 5 minutes before refreshing the page.
Llama 2 API dashboard interface

Generate SSL Manually

Llama 2 will automatically try to setup SSL based on provided domain name, if that domain is hosted on Route53. If it's unsuccessful then you have to setup SSL manually.

Step 1: Copy IP Address

  1. Proceed with the instructions outlined in the above "Update DNS" section, if you have not already done so.
  2. Copy the Public IP address indicated as "PublicIp" in the "Outputs" tab.
Copying the PublicIp from CloudFormation Outputs tab

Step 2: Log in to the server

  1. Open the terminal and go to the directory where your private key is located.
  2. Paste the following command into your terminal and press Enter:
ssh -i <your key name> ubuntu@<Public IP address>
    Logging into the Llama 2 server via SSH
  1. Type "yes" and press Enter. This will log you into the server.

Step 3: Generate SSL

Paste the following command into your terminal and press Enter and follow the instructions:

sudo /root/certificate_generate_standalone.sh

Admin Email is required to generate SSL certificates.

Shutting Down Llama

  1. Click the link labeled "Llama" in the "Resources" tab to access the EC2 instance, you will be directed to the Llama instance in EC2.
Resources tab showing the Llama 2 EC2 instance link
  1. Select the Llama instance by marking the checkbox and click "Stop instance" from the "Instance state" dropdown. You can restart the instance at your convenience by selecting "Start instance".
Stopping the Llama 2 EC2 instance

Remove Llama

Delete the stack that has been created in the AWS Management Console under "CloudFormation Stacks" by clicking the "Delete" button.

API Documentation

1. Retrieve Completions from CoPilot Codex Engine

Retrieves completions from the CoPilot Codex Engine based on the provided prompt.

  • Endpoint: /v1/engines/copilot-codex/completions
  • Method: POST
  • Request Body:
{
  "prompt": "\n\n### Instructions:\nWhat is the capital of France?\n\n### Response:\n",
  "stop": ["\n", "###"]
}

Response Body:

{
    "id": "cmpl-91cb1316-fff4-450d-8c01-ad98737afb9d",
    "object": "text_completion",
    "created": 1697623333,
    "model": "/root/models/llama-2-13b-chat.Q5_K_M.gguf",
    "choices": [
        {
            "text": "The capital of France is Paris.",
            "index": 0,
            "logprobs": null,
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 25,
        "completion_tokens": 7,
        "total_tokens": 32
    }
}

2. Retrieve Completions

Retrieves completions based on the provided prompt.

  • Endpoint: /v1/completions
  • Method: POST
  • Request Body:
{
  "prompt": "\n\n### Instructions:\nWhat is the capital of France?\n\n### Response:\n",
  "stop": ["\n", "###"]
}

Response Body:

{
    "id": "cmpl-91cb1316-fff4-450d-8c01-ad98737afb9d",
    "object": "text_completion",
    "created": 1697623333,
    "model": "/root/models/llama-2-13b-chat.Q5_K_M.gguf",
    "choices": [
        {
            "text": "The capital of France is Paris.",
            "index": 0,
            "logprobs": null,
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 25,
        "completion_tokens": 7,
        "total_tokens": 32
    }
}

3. Retrieve Embeddings

Retrieves embeddings based on the provided input text.

  • Endpoint: /v1/embeddings
  • Method: POST
  • Request Body:
{
  "input": "The food was delicious and the waiter..."
}

Response Body:

{
    "object": "list",
    "data": [
        {
            "object": "embedding",
            "embedding": [
                -0.07521496713161469,
                0.44098934531211853,
                0.6786724328994751
            ],
            "index": 0
        }
    ],
    "model": "/root/models/llama-2-13b-chat.Q5_K_M.gguf",
    "usage": {
        "prompt_tokens": 11,
        "total_tokens": 11
    }
}

4. Retrieve Chat Completions

Retrieves chat completions based on the provided chat messages.

  • Endpoint: /v1/chat/completions
  • Method: POST
  • Request Body:
{
  "messages": [
    {
      "content": "You are a helpful assistant.",
      "role": "system"
    },
    {
      "content": "What is the capital of France?",
      "role": "user"
    }
  ]
}

Response Body:

{
    "id": "chatcmpl-68a41146-ddc6-43e4-b12e-760be6e59e57",
    "object": "chat.completion",
    "created": 1697625763,
    "model": "/root/models/llama-2-13b-chat.Q5_K_M.gguf",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "Bonjour! The capital of France is Paris (pronounced \"pah-ree\"). It's a beautiful city known for its art, fashion, cuisine, and rich history. Do you have any other questions about France or Paris?"
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 37,
        "completion_tokens": 85,
        "total_tokens": 122
    }
}

5. List Models

Retrieves a list of available models.

  • Endpoint: /v1/models
  • Method: GET
  • Response Body:
{
    "object": "list",
    "data": [
        {
            "id": "/root/models/llama-2-13b-chat.Q5_K_M.gguf",
            "object": "model",
            "owned_by": "me",
            "permissions": []
        }
    ]
}

Testing the API

  1. Create a directory.
  2. Create 3 files (full code is given below): app.js, package.json, .env
  3. Run the following command:
npm install
  1. Edit the variable file (.env).
  2. Run the following command:
npm start
  1. You will get the responses.

app.js

const axios = require('axios');
require('dotenv').config();

const makePostRequest = async (url, data, timeout) => {
  try {
    const response = await axios.post(url, data, { timeout });
    return { success: response.status === 200, data: response.data };
  } catch (error) {
    return { success: false, error: error.message };
  }
};

const makeGetRequest = async (url, timeout) => {
  try {
    const response = await axios.get(url, { timeout });
    return { success: response.status === 200, data: response.data };
  } catch (error) {
    return { success: false, error: error.message };
  }
};

const printResponseData = (endpoint, data) => {
  console.log(`Response for ${endpoint}:`);
  console.log(JSON.stringify(data, null, 2));
  console.log('');
};

const checkEndpoints = async () => {
  const baseUrl = process.env.BASE_URL;
  const model = process.env.MODEL;

  const endpoints = [
    { path: '/completions', method: makePostRequest, data: { "model": model, "prompt": process.env.PROMPT1 }, printEnv: 'PRINT_COMPLETIONS_RESPONSE' },
    { path: '/embeddings', method: makePostRequest, data: { "input": process.env.PROMPT2, "model": model }, printEnv: 'PRINT_EMBEDDINGS_RESPONSE' },
    { path: '/chat/completions', method: makePostRequest, data: { "messages": [{ "content": "You are a helpful assistant.", "role": "system" }, { "content": process.env.PROMPT1, "role": "user" }], "model": model }, printEnv: 'PRINT_CHAT_COMPLETIONS_RESPONSE' },
    { path: '/models', method: makeGetRequest, printEnv: 'PRINT_MODELS_RESPONSE' }
  ];

  for (const endpoint of endpoints) {
    const url = `${baseUrl}${endpoint.path}`;
    const { success, data, error } = await endpoint.method(url, endpoint.method === makePostRequest ? endpoint.data : null, process.env.REQUEST_TIMEOUT || 50000);
    const printResponse = process.env[endpoint.printEnv] === 'true';

    if (success) {
      console.log(`*** Endpoint ${endpoint.path} is reachable.`);
      if (printResponse) {
        printResponseData(endpoint.path, data);
      }
      console.log('');
    } else {
      console.log(`*** Endpoint ${endpoint.path} is not reachable. Error:`, error);
    }
  }
};

checkEndpoints();

package.json

{
  "name": "test-llama",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node app.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "axios": "^1.6.7",
    "dotenv": "^16.4.1"
  }
}

.env

# Base URL for the API
BASE_URL=https://mixtral-test-prod.meetrix.io/v1

# Model to be used in requests
MODEL=mixtral-8x7b-instruct-v0.1

# Prompts for different endpoints
# /completions and /chat/completions
PROMPT1=What is the capital of France?
# /embeddings
PROMPT2=The food was delicious and the waiter...

# Whether to print responses for each endpoint
PRINT_COMPLETIONS_RESPONSE=true
PRINT_EMBEDDINGS_RESPONSE=false
PRINT_CHAT_COMPLETIONS_RESPONSE=true
PRINT_MODELS_RESPONSE=true

# Timeout for requests in milliseconds (default is 50000)
REQUEST_TIMEOUT=50000

Check Server Logs

Step 1: Log in to the server

  1. Open the terminal and go to the directory where your private key is located.
  2. Paste the following command into your terminal and press Enter:
ssh -i <your key name> ubuntu@<Public IP address>
Logging into the Llama 2 server via SSH to check logs

Step 2: Check the logs

sudo tail -f /var/log/syslog

Upgrades

When there is an upgrade, we will update the product with a newer version. You can check the product version in AWS Marketplace. If a newer version is available, you can remove the previous version and launch the product again using the newer version. Remember to backup the necessary server data before removing.

Troubleshoot

  1. If you face the following error, please follow https://meetrix.io/blogs/increase-aws-vcpu-quota/ to increase vCPU quota.
AWS vCPU quota exceeded error
  1. If you face the following error ("do not have sufficient <instance_type> capacity...") while creating the stack, try changing the region or try creating the stack at a later time.
AWS insufficient instance capacity error
  1. If you face the below error, when you try to access the API dashboard, please wait 5-10 minutes and then try.
502 Bad Gateway error

Conclusion

In conclusion, the Llama 2 Developer Guide equips you with everything you need for a seamless integration of Llama into your AWS setup. Whether you're a novice or an experienced developer, our guide offers detailed, step-by-step instructions to ensure a smooth setup process, with optimized AMIs and OpenAI API compatibility for streamlined generative text operations.

Technical Support

Reach out to Meetrix Support (aws@meetrix.io) for assistance with Llama 2 issues.

Frequently Asked Questions

What is Llama 2?

Llama 2 is Meta's pre-trained generative text model. These Amazon Machine Images are fully optimized for developers utilizing advanced text generation, with an OpenAI-compatible API for seamless integration.

What are the prerequisites for deploying Llama 2 on AWS?

You need basic knowledge of AWS services (EC2, CloudFormation), an active AWS account with appropriate permissions, and enough vCPU limit to launch a g4dn instance type.

Which instance type is recommended for Llama 2?

g4dn.xlarge is recommended for the 7B model, while g4dn.12xlarge is recommended for the 70B model.

How do I test the Llama 2 API after deployment?

Create a small Node.js script with app.js, package.json, and a .env file, run npm install followed by npm start, and it will check the /completions, /embeddings, /chat/completions, and /models endpoints and print the responses.

What should I do if I get a 502 Bad Gateway error?

Wait approximately 5 minutes and then refresh the page. The API can take a few minutes to become available after the stack finishes creating.

How do I generate SSL manually?

If automatic SSL setup fails because your domain isn't hosted on Route 53, SSH into the server and run <code>sudo /root/certificate_generate_standalone.sh</code>. The Admin Email you provided during stack creation is required for certificate generation.

How do I get technical support?

Reach out to Meetrix Support at <a href='mailto:aws@meetrix.io'>aws@meetrix.io</a> for assistance with Llama 2 issues.

Ready to Deploy Your Own Llama 2 Instance?

Get started in minutes with our pre-configured AMI and bring Meta's Llama 2 to your AWS environment.

Deploy Llama 2 from AWS Marketplace