Generate Dynamic Code with CodeLLaMA Cognitive Actions

24 Apr 2025
Generate Dynamic Code with CodeLLaMA Cognitive Actions

The nateraw/codellama-7b-instruct-hf API provides powerful Cognitive Actions designed for developers looking to leverage advanced code generation capabilities. Among these, the Generate Code with CodeLLaMA action stands out for its ability to produce code snippets based on user-defined instructions. This action offers fine-tuned control over the generation process through parameters like Top K, Top P, Temperature, and Max New Tokens, making it a versatile tool for various coding tasks.

Prerequisites

Before diving into using the Cognitive Actions, ensure that you have the following prerequisites:

  • API Key: You need to authenticate your requests using an API key for the Cognitive Actions platform.
  • Basic HTTP Client: Familiarity with making HTTP requests in your programming language of choice (for the provided example, we’ll use Python).

Authentication typically involves passing the API key in the request headers, ensuring that only authorized users can access the service.

Cognitive Actions Overview

Generate Code with CodeLLaMA

The Generate Code with CodeLLaMA action allows you to utilize the CodeLLaMA-7b-instruct-hf model to generate code predictions based on input instructions. This action is categorized under code-generation and is particularly useful for automating the creation of code snippets based on natural language descriptions.

Input

The input schema for this action requires the following fields:

  • message (required): A string containing the instructions for the code generation.
  • topK (optional): An integer that specifies the number of top-probability tokens to consider (default is 50).
  • topP (optional): A probability threshold that retains tokens whose cumulative probability meets or exceeds this value (default is 1.0).
  • temperature (optional): A number controlling the randomness of predictions (default is 1).
  • maxNewTokens (optional): An integer that sets the maximum number of tokens to be generated (default is 256).

Example Input:

{
  "topK": 50,
  "topP": 0.95,
  "message": "Write a function to load a csv file and find the 3 day rolling average of the \"profit\" column using the \"date\" column.",
  "temperature": 1,
  "maxNewTokens": 1024
}

Output

The expected output is a list of strings that represent the generated code. The output varies based on the input message and parameters used but typically includes well-structured code that meets the provided instructions.

Example Output:

[
  "",
  " ",
  "Here ",
  "is ",
  "a ",
  "sample ",
  "code ",
  "that ",
  "demonstrates ",
  "how ",
  "to ",
  "load ",
  "a ",
  "CSV ",
  "file ",
  "and ",
  "calculate ",
  "the ",
  "3-day ",
  "rolling ",
  "average ",
  "of ",
  "the ",
  "profit",
  "column ",
  "using ",
  "the ",
  "date",
  "column:\n",
  "```\n",
  "import ",
  "csv\n",
  "\n",
  "# ",
  "Define ",
  "the ",
  "file ",
  "path ",
  "and ",
  "header ",
  "row\n",
  "file_path ",
  "= ",
  "'file.csv'\n",
  "header ",
  "= ",
  "['date', ",
  "'profit']\n",
  "\n",
  "# ",
  "Load ",
  "the ",
  "CSV ",
  "file\n",
  "with ",
  "open(file_path, ",
  "'r') ",
  "as ",
  "csvfile:\n",
  "  ",
  "reader ",
  "= ",
  "csv.reader(csvfile)\n",
  "  ",
  "# ",
  "Skip ",
  "the ",
  "header ",
  "row\n",
  "  ",
  "next(reader)\n",
  "  ",
  "# ",
  "Store ",
  "the ",
  "data ",
  "in ",
  "a ",
  "list ",
  "of ",
  "dictionaries\n",
  "  ",
  "data ",
  "= ",
  "[dict(zip(header, ",
  "row)) ",
  "for ",
  "row ",
  "in ",
  "reader]\n",
  "\n",
  "# ",
  "Calculate ",
  "the ",
  "3-day ",
  "rolling ",
  "average ",
  "of ",
  "the ",
  "profit",
  "column\n",
  "rolling_average ",
  "= ",
  "[\n",
  "  ",
  "sum(data[i]['profit'] ",
  "for ",
  "i ",
  "in ",
  "range(x, ",
  "x ",
  "+ ",
  "3)) ",
  "/ ",
  "3 ",
  "for ",
  "x ",
  "in ",
  "range(len(data))\n",
  "]\n",
  "\n",
  "# ",
  "Print ",
  "the ",
  "rolling ",
  "average\n",
  "for ",
  "i ",
  "in ",
  "rolling_average:\n",
  "  ",
  "print(i)\n",
  "```\n",
  "This ",
  "code ",
  "loads ",
  "the ",
  "CSV ",
  "file ",
  "using ",
  "the ",
  "`csv` ",
  "module ",
  "and ",
  "stores ",
  "the ",
  "data ",
  "in ",
  "a ",
  "list ",
  "of ",
  "dictionaries. ",
  "It ",
  "then ",
  "calculates ",
  "the ",
  "3-day ",
  "rolling ",
  "average ",
  "of ",
  "the ",
  "profit",
  "column ",
  "using ",
  "a ",
  "loop ",
  "that ",
  "iterates ",
  "over ",
  "the ",
  "data ",
  "and ",
  "calculates ",
  "the ",
  "sum ",
  "of ",
  "the ",
  "profits ",
  "for ",
  "the ",
  "current ",
  "and ",
  "the ",
  "previous ",
  "two ",
  "days. ",
  "Finally, ",
  "it ",
  "prints ",
  "the ",
  "rolling ",
  "average."
]

Conceptual Usage Example (Python)

Here’s how you might call this action using a conceptual Python code snippet:

import requests
import json

# Replace with your Cognitive Actions API key and endpoint
COGNITIVE_ACTIONS_API_KEY = "YOUR_COGNITIVE_ACTIONS_API_KEY"
COGNITIVE_ACTIONS_EXECUTE_URL = "https://api.cognitiveactions.com/actions/execute" # Hypothetical endpoint

action_id = "9f0f23b3-a4b4-452f-a240-4bcf965b3119"  # Action ID for Generate Code with CodeLLaMA

# Construct the input payload based on the action's requirements
payload = {
    "topK": 50,
    "topP": 0.95,
    "message": "Write a function to load a csv file and find the 3 day rolling average of the \"profit\" column using the \"date\" column.",
    "temperature": 1,
    "maxNewTokens": 1024
}

headers = {
    "Authorization": f"Bearer {COGNITIVE_ACTIONS_API_KEY}",
    "Content-Type": "application/json"
}

try:
    response = requests.post(
        COGNITIVE_ACTIONS_EXECUTE_URL,
        headers=headers,
        json={"action_id": action_id, "inputs": payload}  # Hypothetical structure
    )
    response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)

    result = response.json()
    print("Action executed successfully:")
    print(json.dumps(result, indent=2))

except requests.exceptions.RequestException as e:
    print(f"Error executing action {action_id}: {e}")
    if e.response is not None:
        print(f"Response status: {e.response.status_code}")
        try:
            print(f"Response body: {e.response.json()}")
        except json.JSONDecodeError:
            print(f"Response body: {e.response.text}")

In this example, replace the placeholder API key and endpoint with your actual credentials. The action_id variable holds the ID for the Generate Code with CodeLLaMA action, while the payload variable structures the input according to the action's requirements.

Conclusion

The Generate Code with CodeLLaMA action offers a powerful way to automate code generation tasks based on natural language input, significantly enhancing developer productivity. By controlling parameters such as Top K, Top P, Temperature, and Max New Tokens, you can tailor the generated output to suit your needs. Consider exploring additional use cases such as generating boilerplate code, creating unit tests, or even developing complex algorithms. Integrating these Cognitive Actions into your applications can streamline your workflow and unlock new possibilities in code generation.

← Back to All Articles