LLM for Elementary School Students

The hottest keyword in the industry these days is LLM.
Models like Claude 3.5 and Grok3 are constantly emerging,
and services utilizing LLMs, such as Character.AI, are also increasing.

As developers, we'll likely integrate LLMs into our services someday,
so it's a good idea to familiarize ourselves with the basic concepts beforehand to avoid confusion!
So, I've summarized the key keywords.

---

LLM
Simply put, LLM (Large Language Model) is
"an AI that understands text input and responds with text."
Models like GPT-4, Claude 3, and Grok3 are prime examples.

These days, LLMs go beyond simply generating sentences,
performing various tasks such as coding, image analysis, and solving equations.
It seems we've entered an era where developers utilize AI as a tool.

---

Tool Call, Function Call
LLMs don't just provide answers; they can also be instructed to
"call the necessary tools to assist with the task."

For example,

If a user says, "Calculate this number,"
the LLM requests the calculator API to be called,
and then delivers the result back to the user.
However, the LLM itself doesn't directly call the API;
we need to implement the actual call in code 😢

---

RAG (Retrieval-Augmented Generation)
No matter how intelligent an LLM is,
it generates answers based only on the data it has been trained on.
So, how does it retrieve information like the latest news or internal documents?

That's where RAG comes in.

It first searches (Retrieval) for necessary information from an external database,
and then generates (Generation) an answer based on that information.
This allows the LLM to incorporate up-to-date information.

In short, before the LLM answers, it's fed the necessary materials for the answer, and the summarization or answering based on those materials is all called RAG.

---

4B, 8B, 308B? What do these numbers mean?

When you look at LLM models, you'll see numbers like 8B and 70B attached.
This refers to the number of parameters (Parameter) the model has been trained on.

8B (8 billion) → Lightweight model, fast
308B (308 billion) → Extremely large model, but slow

Larger models are more accurate, but speed and cost can be a burden.
These days, effectively utilizing lightweight models is a trend.

Heavier models result in slower response times,
leading to higher churn rates among end-users.

---

Multi-Agent
Instead of an LLM handling everything alone,
multiple smaller AI's (agents) work collaboratively.

For example:

One handles coding,
another handles data analysis,
and another handles document organization.
Dividing roles like this results infaster speeds and more accurate responses.
Isn't it just like a company? Someone handles the frontend... someone handles the backend...

---

Validation Feedback
LLMs don't always give the right answer.
They might provide incorrect answers.

Therefore, **Validation Feedback **is necessary.

If the user provides feedback on whether the LLM's response is correct or incorrect,
the model can become increasingly intelligent.
This can be automated to create a self-learning system for the LLM.

Or, when Function Call or response format is defined,
if it doesn't follow the format, it can be forced to follow it.

Using Function Call in OpenAI
To actually use Function Call with OpenAI's GPT-4,
it can be implemented as follows.

🔹 TypeScript Example

import { OpenAI } from "openai";

const openai = new OpenAI({ apiKey: "YOUR_API_KEY" });

async function callFunction() {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      { role: "user", content: "Tell me the current time" }
    ],
    functions: [
      {
        name: "get_current_time",
        description: "Returns the current time.",
        parameters: {},
      },
    ],
    function_call: "auto",
  });

  if (response.choices[0].message.function_call) {
    console.log("Function called by LLM:", response.choices[0].message.function_call.name);
  }
}

callFunction();

By using Function Call in this way,
LLMs can evolve into a "truly useful AI" that performs actual functions, rather than just generating text.

---

Agentica

Carefully filling in argument values for these Function Calls can be quite tedious.
Therefore, services like Vercel AI and LangChain use the zod library to
perform Validation Feedback on whether the argument values returned by the LLM are correct.

This ensures highly accurate Function Calls.

However, writing schemas for each argument of complex functions using zod can be very cumbersome, and
developers might find it "tedious".

Therefore, I recommend the Agentica library.

import { Agentica } from "@agentica/core";
import typia from "typia";

const agent = new Agentica({
  controllers: [
    await fetch(
      "https://shopping-be.wrtn.ai/editor/swagger.json",
    ).then(r => r.json()),
    typia.llm.application<ShoppingCounselor>(),
    typia.llm.application<ShoppingPolicy>(),
    typia.llm.application<ShoppingSearchRag>(),
  ],
});
await agent.conversate("I wanna buy MacBook Pro");

With this simple code, functions in three classes and swagger endpoints are
designated as Function Calls and automatically called during conversations.

This creates a simple "chatbot agent".

The field of handling LLMs and AI is becoming increasingly user-friendly.
The advancement of technology is truly awe-inspiring.