Code Explanation: think.js

This file demonstrates using system prompts for logical reasoning and quantitative problem-solving, showing how to configure an LLM as a specialized reasoning agent.

Step-by-Step Code Breakdown

1. Import and Setup (Lines 1-8)

import {
    getLlama,
    LlamaChatSession,
} from "node-llama-cpp";
import {fileURLToPath} from "url";
import path from "path";
 
const __dirname = path.dirname(fileURLToPath(import.meta.url));

Standard imports for LLM interaction
Path setup for locating the model file

2. Initialize and Load Model (Lines 10-18)

const llama = await getLlama();
const model = await llama.loadModel({
    modelPath: path.join(
        __dirname,
        "../",
        "models",
        "Qwen3-1.7B-Q6_K.gguf"
    )
});

Uses Qwen3-1.7B-Q6_K: A 1.7B parameter model with 6-bit quantization
Smaller than the translation example (1.7B vs 8B parameters)
Q6_K quantization provides a balance between size and quality

3. Define the System Prompt (Lines 19-24)

const systemPrompt = `You are an expert logical and quantitative reasoner.
    Your goal is to analyze real-world word problems involving families, quantities, averages, and relationships 
    between entities, and compute the exact numeric answer.
    
    Goal: Return the correct final number as a single value — no explanation, no reasoning steps, just the answer.
    `

Key elements:

Role: “expert logical and quantitative reasoner”
- Sets expectations for mathematical/analytical thinking
Task Scope: “real-world word problems involving families, quantities, averages, and relationships”
- Tells the model what type of problems to expect
- Primes it for complex counting and calculation tasks
Output Constraint: “Return the correct final number as a single value — no explanation”
- Forces concise output
- Just the answer, not the work

Why This System Prompt Design?

The prompt is designed for the specific problem type:

Word problems with complex family relationships
Multiple nested conditions
Requires careful tracking of people and quantities
Needs arithmetic calculation

4. Create Context and Session (Lines 25-29)

const context = await model.createContext();
const session = new LlamaChatSession({
    contextSequence: context.getSequence(),
    systemPrompt
});

Creates context for the conversation
Initializes session with the reasoning system prompt
No chat wrapper needed (using model’s default format)

5. The Complex Word Problem (Lines 31-40)

const prompt = `My family reunion is this week, and I was assigned the mashed potatoes to bring. 
The attendees include my married mother and father, my twin brother and his family, my aunt and her family, my grandma 
and her brother, her brother's daughter, and his daughter's family. All the adults but me have been married, and no one 
is divorced or remarried, but my grandpa and my grandma's sister-in-law passed away last year. All living spouses are attending. 
My brother has two children that are still kids, my aunt has one six-year-old, and my grandma's brother's daughter has 
three kids under 12. I figure each adult will eat about 1.5 potatoes and each kid will eat about 1/2 a potato, except my 
second cousins don't eat carbs. The average potato is about half a pound, and potatoes are sold in 5-pound bags. 
 
How many whole bags of potatoes do I need? 
`;

This is intentionally complex to test reasoning:

People to count:

Speaker (1)
Mother and father (2)
Twin brother + spouse (2)
Brother’s 2 kids (2)
Aunt + spouse (2)
Aunt’s 1 kid (1)
Grandma (1)
Grandma’s brother + spouse (2)
Brother’s daughter + spouse (2)
Their 3 kids (3, but don’t eat carbs)

Calculations needed:

Count total adults
Count total kids
Subtract non-eating kids
Calculate potato needs: (adults × 1.5) + (eating kids × 0.5)
Convert to pounds: total potatoes × 0.5 lbs
Convert to bags: pounds ÷ 5, round up

The complexity:

Family relationships (who’s married to whom)
Deceased people (subtract from count)
Special dietary needs (second cousins don’t eat carbs)
Unit conversions (potatoes → pounds → bags)

6. Execute and Display (Lines 42-43)

const answer = await session.prompt(prompt);
console.log(`AI: ${answer}`);

Sends the complex problem to the model
The model uses its reasoning abilities to work through the problem
Outputs just the final number (based on system prompt)

7. Cleanup (Lines 45-48)

session.dispose()
context.dispose()
model.dispose()
llama.dispose()

Standard resource cleanup

Key Concepts Demonstrated

1. Reasoning Agent Configuration

This shows how to configure an LLM for analytical thinking:

System Prompt → LLM becomes a "reasoning engine"

Instead of conversational AI, we get:

Focused analytical processing
Mathematical computation
Logical deduction

2. Output Format Control

Compare these approaches:

Without constraint:

AI: Let me work through this step by step.
First, I'll count the adults...
[lengthy explanation]
So the answer is 3 bags.

With constraint (this example):

AI: 3

3. Problem Complexity Testing

This example tests the model’s ability to:

Parse complex natural language
Track multiple entities and relationships
Apply arithmetic operations
Handle edge cases (deceased people, dietary restrictions)
Perform unit conversions

4. Specialized Task Agents

This demonstrates creating task-specific agents:

General LLM + "Reasoning Agent" System Prompt = Math Problem Solver

Same pattern works for:

Logic puzzles
Data analysis
Scientific calculations
Statistical reasoning

Challenges & Limitations

1. Model Size Matters

The 1.7B parameter model may struggle with:

Very complex counting problems
Multi-step reasoning requiring working memory
Edge cases in the problem

Larger models (7B, 13B+) generally perform better on reasoning tasks.

2. Hidden Reasoning

The system prompt asks for “just the answer,” so we don’t see:

The model’s reasoning process
Where it might have made mistakes
Its confidence level

3. No Tool Use

The model must do all calculations “in its head” without:

A calculator
Note-taking
Step-by-step verification

Later examples (like react-agent) address this by giving the model tools.

Why This Matters for AI Agents

Reasoning is Fundamental

All useful agents need reasoning capabilities:

Planning agents: Reason about sequences of actions
Research agents: Analyze and synthesize information
Decision agents: Evaluate options and consequences

System Prompt Shapes Behavior

This example shows that the same model can behave differently based on instructions:

Translator agent (previous example)
Reasoning agent (this example)
Code agent (later examples)

Foundation for Complex Agents

Understanding how to prompt for reasoning is essential before adding:

Tools (giving the model a calculator)
Memory (remembering previous calculations)
Multi-step processes (ReAct pattern)

Expected Output

Running this script should output something like:

AI: 3

The exact answer depends on the model’s ability to:

Correctly count all family members
Apply the eating rates
Convert units
Round up for whole bags

Improving This Approach

To get better reasoning:

Use larger models: 7B+ parameters
Add step-by-step prompting: “Show your work”
Provide tools: Give the model a calculator
Use chain-of-thought: Encourage explicit reasoning
Verify answers: Run multiple times or use multiple models

The react-agent example demonstrates some of these improvements.

Ai 마법서

Explorer

CODE