Welcome to alphawave Discussions!

[Stevenic]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[rmolinamir]

Hello @Stevenic, and everyone else reading this in the future as well! 👋

I'm a software engineer who stumbled upon this awesome AI client while working on a project at my company :)

I've been using AlphaWave to automate some of our processes such as the translation of subtitles (think of SRT or VTT files), generating text from audio, then formatting the text into SRT or VTT, there are a few other goals such as getting metadata about the media, or the number of different actors, the percentage of the script for each actor, etc.

So I was blown away at how much it helps when interfacing with AI clients, I'm also planning to use it in some side projects I've been working on, and given that the project is just getting started I wanted to help out as much as I can!

Though I'm not entirely sure where to start, here are some ideas:

• Perhaps the prompt options could be improved a bit, for example, I think if you combine a completion_type of chat with a model such as text-davinci-003 you'll run into errors.
• I'm excited about the new functions calling API as well, it looks incredible especially if using CQS models, I wonder if the API can essentially function as a command/query bus?
• I would recommend release-it to help with the publishing to the NPM registry, it's awesome!

If you have any other ideas let me know! I noticed you mentioned you've been working on the new function calling API in the functions branch, looks exciting.

[Stevenic]

Thanks @rmolinamir… I’m glad you’ve taken the time to give AlphaWave a try and are seeing benefits.

If you’re you’re asking for simple text based responses from the model you’re calling then you don’t really need AlphaWave. If, however, you’re looking for the model to return structured responses, like JSON, then I personally believe AlphaWave will make the model as reliable as it can be at that task. If you give AlphaWave a try and for some reason you get back invalid JSON response please turn on logRequests and share your prompt with me. Out of well over 1,000 request I’ve seen 3 invalid responses. 2 we’re because I had the wrong validator wired to the prompt and 1 was a legit bug with the feedback I was giving the model but an hour in playground and the issue was fixed. I’ve seen AlphaWave repair hundreds of responses but it’s able to repair those responses every single time using even GPT-3.5.

im hoping to have support for OpenAI functions finished this week and it will make the functions returned by the models reliable and mostly hallucination free meaning that it won’t be allowed to hallucinate functions that don’t exist and will be required to return all required parameters to your app. OpenAI doesn’t currently guarantee any of this but AlphaWave will add that additional layer of reliability

[rmolinamir]

Oh, I absolutely agree. I think that your emphasis on reliability is the most important aspect that makes this client so good in production. My approach was to define a common schema that multiple subtitle formats could convert to and from, it looks something like { lang: string; segments: Array<{ id: string; text: string }>; }, it's really good at understanding TypeScript types as schemas.

Additionally, I asked OpenAI to return a response in the same schema so that I could convert it back into its respective file format, and the JSON schema validator is also incredibly useful for this. I had to also break down the file into multiple "chunks" depending on the number of tokens, and then do one HTTP request for each of them. I do remember running into an issue early on where I asked OpenAI to process an input of this schema { lang: string; segments: Array<{ id: string; text: string }>; } and to return a translated output of this schema Array<{ id: string; text: string }>;, but it was having a rough time, so I decided to just keep the schemas themselves the same and instead just asked it to translate the text fields, that did the trick. Next time I run into something like this I'll make sure to log the requests and share them with you.

Really looking forward to your implementation of the function calling API, I can't wait to try it out. It's going to essentially be a natural language interface with an application layer, that's crazy!

[Stevenic]

@rmolinamir I have function calling support working...

[rmolinamir]

This is awesome. I left some feedback in #11 and opened PR #10 containing a cool sample project, let me know what you think :)

[LaysDragon]

I'm struggling with AI keep calling "python" function and try to maintain the structured data. Then I follow from search to here. It's a great project to help me solve the structure problem.

Now I totally give up the function call,I found out its will serious interfering with AI. But here is something I came out within the process, a CompositeValidator that can composite validators together when I need to use function call and structured response at the sametime.

interface CompisiteItem {
    test: (memory: PromptMemory, functions: PromptFunctions, tokenizer: Tokenizer, response: PromptResponse, remaining_attempts: number) => boolean;
    validator: PromptResponseValidator;
}

export class CompositeResponseValidator implements PromptResponseValidator {
    constructor(private items: CompisiteItem[]) { }

    public async validateResponse(memory: PromptMemory, functions: PromptFunctions, tokenizer: Tokenizer, response: PromptResponse, remaining_attempts: number): Promise<Validation> {
        let validator = this.items.find(i => i.test(memory, functions, tokenizer, response, remaining_attempts))?.validator;
        if(validator !== undefined){
            return validator.validateResponse(memory, functions, tokenizer, response, remaining_attempts);
        }else{
            return Promise.resolve({
                type: 'Validation',
                valid: true,
            });
        }
        
    }
}

Then you setup the validators base on different condition.

const validator =  new CompositeResponseValidator([
                {
                    test: (memory, functions, tokenizer, response, remaining_attempts) => {
                        return (response.message as Message).function_call !== undefined;
                    },
                    validator: new FunctionResponseValidator(model.options.functions),
                },
                {
                    test: () => true,
                    validator: new JSONResponseValidator(task.schema),
                },
            ]);