Return always JSON response using assistant API

API
1

Hi There,
I am currently using node js openai package, and create assistant in playground and feed some JSON format files to it.
It works great when i search something and GPT response back in descriptive manner.
However like completion API there is a method function_call which force API to use that function to response back in specific format.
How i can achieve this in assistant API, i want to return JSON response always.
For example:

await openai.beta.threads.runs.submitToolOutputs(
                    thread.id,
                    run.id,
                    {
                      tool_outputs: [
                        {
                          tool_call_id: toolCall?.id,
                          output: JSON.stringify({'first_name': args.first_name, 'last_name' : args.last_name}),
                        },
                      ],
                    },
                );

I am using this code to submit my tool output.
But finally appending response like this.

if (messageValue && messageValue.text && messageValue.text.value) {
                console.log(messageValue.text.value)
                socket.emit('message', {
                    role: 'ai',
                    content: JSON.parse(messageValue.text.value)
                });
            }

I did not find any valuable help regarding this on net, Kindly put me in the right direction.

Thanks

1 Like
2

hay did u forget to add the semicolon
like this
;

> if (messageValue && messageValue.text && messageValue.text.value) {
  const jsonResponse = JSON.parse(messageValue.text.value);


  console.log(jsonResponse);

  socket.emit('message', {
    role: 'ai',
    content: jsonResponse,
  });
}
3

semicolons are used to do like a check list of what does what and when to do this and other functions i like to think of it like the exact function then moving to next till deactivates function is active. right now you’re close but missing the check list. Easy fixes

4

@michael.simpson555 Its not related to semicolon, but its a good practice to always end your statement.
My Main concern is that how i can get the always JSON formatted response.
I do not want to use prompt thing, because prompt did not always 100% right, wo i have to use function calling with assistant api, we have our own data which we want to train with assistant api.
But i am not sure here how i can get back the formatted response.
Thanks

5

To ensure that the response is always in JSON format, you need to structure your tool output like
this

`await openai.beta.threads.runs.submitToolOutputs(
    thread.id,
    run.id,
    {
        tool_outputs: [
            {
                tool_call_id: toolCall?.id,
                output: JSON.stringify({'first_name': args.first_name, 'last_name' : args.last_name}),
            },
        ],
    },
);
`

mit work but I don’t know cuz im not looking at the whole code using JSON.parse to convert the received response back into a JavaScript object. This is also correct and aligns with your goal of working with JSON.

if (messageValue && messageValue.text && messageValue.text.value) {
    console.log(messageValue.text.value)
    socket.emit('message', {
        role: 'ai',
        content: JSON.parse(messageValue.text.value)
    });
}

and u must fine tune it

6

Hi @michael.simpson555
I am trying to get the structured response and currently using GPT 3.5.
Here is my code:

import OpenAI from "openai";
import dotenv from "dotenv";

dotenv.config();
const openai = new OpenAI({apiKey: process.env.OPENAI_API_KEY});

const setTalentDataJson = {
    "name": "setTalentInfo",
    "description": "Get the tagline and languages of a talent.",
    "parameters": {
        "type": "object",
        "properties": {
            "tagline": {
                "type": "string",
                "description": "The tagline of the talent."
            },
            "languages": {
                "type": "string",
                "description": "The language of the talent."
            },
            "bio": {
                "type": "string",
                "description": "The bio of the talent."
            }
        },
        // "required": ["tagline", "languages"]
    }
};

const getTalentDataJson = {
    "name": "getTalentInfo",
    "description": "Get the tagline and languages of a talent.",
    "parameters": {
        "type": "object",
        "properties": {
            "tagline": {
                "type": "string",
                "description": "The tagline of the talent."
            },
            "languages": {
                "type": "string",
                "description": "The language of the talent."
            }
        },
        // "required": ["tagline", "languages"]
    }
};

const getTalentInfo = async ( tagline, languages)  => {
    const talent_data = {
        "first_name": "John",
        "last_name": "Doe",
        "tagline": "Instructional Designer",
        "bio": "Hi, I'm an Instructional Designer with over 7 years of experience developing end-to-end training solutions. I can help you in all stages of the process: assessing the needs of your learners, creating a strategy to train them more effectively, developing custom e-learning modules and selecting the right LMS for your organization.",
        "location": "Canada",
        "languages": [
            "English",
            "French",
            "Spanish"
        ]
    };
    return talent_data
};

const setTalentInfo = async (tagline, languages, bio) => {
    const talent_data = {
        "tagline": tagline,
        "languages": languages,
        "bio": bio
    };
    return talent_data;
};

async function callGpt(model, systemPrompt, userPrompt) {
    let messages = [
        {role: "system", content: systemPrompt},
        {role: "user", content: userPrompt}
    ];

    console.log('---------- Request -------------');
    console.log(messages);

    const response = await openai.chat.completions.create({
        model: model,
        messages: messages,
        functions: [getTalentDataJson]
    });

    let responseMessage = response.choices[0].message;
    console.log("Got Response: ", responseMessage);
    messages.push(responseMessage);

    if(responseMessage.function_call?.name === 'getTalentInfo') {
        const args = JSON.parse(responseMessage.function_call.arguments);
        const talent = await getTalentInfo(args.tagline, args.languages);

        const talent_data = {"first_name": talent.first_name, "last_name": talent.last_name, "tagline": talent.tagline, "bio": talent.bio, "languages": talent.languages};
        const talent_return_data = await setTalentInfo(talent.tagline, talent.languages, talent.bio);
        
        messages.push({role: "function", name: "getTalentInfo", content: JSON.stringify(talent_return_data)});

        const response2 = await openai.chat.completions.create({
            model: "gpt-3.5-turbo-1106",
            messages: messages,
            functions: [setTalentDataJson],
            function_call: {
                name: "setTalentInfo",
                arguments: JSON.stringify(talent_return_data)
            }
        });

        console.log( response2.choices[0].message)

        if (response2.function_call && response2.function_call.name === 'setTalentInfo') {
            console.log("Response 2", response2.choices[0].message);
            return JSON.parse(response2.function_call.arguments);
        } else {
            console.error("Error in processing the response from OpenAI GPT-3.5-turbo.");
            // Handle the error or provide a default value
            return null;
        }
    }
}

const result = await callGpt("gpt-3.5-turbo-1106",
        "You are a highly experienced talent recruiter. You help people find the right human resource for their needs.",
        "I am looking for Instructional designer who speaks french");

console.log("Result", result);

Whenever function triggers it always return the structured data which i have defined in setTalentData.
Like whatever data search by function call it always return the predefined data like in setTalentData
In this case i want to return tagline, languages, bio. But it did not return the bio, its only return the tagline and languages.
Looking forward

7

the problem lies in how the setTalentInfo function is structured. The talent_data object in the setTalentInfo function only contains tagline and languages . To include the bio in the response, you should modify the talent_data object to include the bio field as well. like so `

import OpenAI from “openai”;
import dotenv from “dotenv”;

dotenv.config();
const openai = new OpenAI({apiKey: process.env.OPENAI_API_KEY});

const setTalentDataJson = {
“name”: “setTalentInfo”,
“description”: “Get the tagline, languages, and bio of a talent.”,
“parameters”: {
“type”: “object”,
“properties”: {
“tagline”: {
“type”: “string”,
“description”: “The tagline of the talent.”
},
“languages”: {
“type”: “string”,
“description”: “The language of the talent.”
},
“bio”: {
“type”: “string”,
“description”: “The bio of the talent.”
}
},
}
};

const getTalentDataJson = {
“name”: “getTalentInfo”,
“description”: “Get the tagline, languages, and bio of a talent.”,
“parameters”: {
“type”: “object”,
“properties”: {
“tagline”: {
“type”: “string”,
“description”: “The tagline of the talent.”
},
“languages”: {
“type”: “string”,
“description”: “The language of the talent.”
}
},
}
};

const getTalentInfo = async (tagline, languages) => {
const talent_data = {
“first_name”: “John”,
“last_name”: “Doe”,
“tagline”: “Instructional Designer”,
“bio”: “Hi, I’m an Instructional Designer with over 7 years of experience developing end-to-end training solutions. I can help you in all stages of the process: assessing the needs of your learners, creating a strategy to train them more effectively, developing custom e-learning modules and selecting the right LMS for your organization.”,
“location”: “Canada”,
“languages”: [
“English”,
“French”,
“Spanish”
]
};
return talent_data;
};

const setTalentInfo = async (tagline, languages, bio) => {
const talent_data = {
“tagline”: tagline,
“languages”: languages,
“bio”: bio
};
return talent_data;
};

async function callGpt(model, systemPrompt, userPrompt) {
let messages = [
{role: “system”, content: systemPrompt},
{role: “user”, content: userPrompt}
];

console.log('---------- Request -------------');
console.log(messages);

const response = await openai.chat.completions.create({
    model: model,
    messages: messages,
    functions: [getTalentDataJson]
});

let responseMessage = response.choices[0].message;
console.log("Got Response: ", responseMessage);
messages.push(responseMessage);

if(responseMessage.function_call?.name === 'getTalentInfo') {
    const args = JSON.parse(responseMessage.function_call.arguments);
    const talent = await getTalentInfo(args.tagline, args.languages);

    const talent_data = {"first_name": talent.first_name, "last_name": talent.last_name, "tagline": talent.tagline, "bio": talent.bio, "languages": talent.languages};
    const talent_return_data = await setTalentInfo(talent.tagline, talent.languages, talent.bio);
    
    messages.push({role: "function", name: "getTalentInfo", content: JSON.stringify(talent_return_data)});
    const response2 = await openai.chat.completions.create({
        model: "gpt-3.5-turbo-1106",
        messages: messages,
        functions: [setTalentDataJson],
        function_call: {
            name: "setTalentInfo",
            arguments: JSON.stringify(talent_return_data)
        }
    });

    console.log(response2.choices[0].message);
    if (response2.function_call && response2.function_call.name === 'setTalentInfo') {
        console.log("Response 2", response2.choices[0].message);
        return JSON.parse(response2.function_call.arguments);
    } else {
        console.error("Error in processing the response from OpenAI GPT-3.5-turbo.");
        // Handle the error or provide a default value
        return null;
    }
}

}

const result = await callGpt(“gpt-3.5-turbo-1106”,
“You are a highly experienced talent recruiter. You help people find the right human resource for their needs.”,
“I am looking for an Instructional designer who speaks French”);

console.log(“Result”, result);

Make sure to include the bio field in the returned object. With this change, when you call this function it should work if its coded right