Forem: IO_Node

Hello again, here's a LangChain Ollama helper sheet :)

IO_Node — Mon, 09 Feb 2026 15:19:25 +0000

LangChain + Ollama: A Practical Guide to Building AI Agents with Python

This guide teaches you how to build real, working AI agents using Ollama and LangChain.

What You'll Learn

In this guide, you'll discover:

✅ How to set up Ollama + LangChain (10 minutes)
✅ When to use ollama.chat() vs ChatOllama() (quick decision tree)
✅ How to build agents that remember things (persistent storage)
✅ Real, working examples (copy & paste ready)
✅ Performance tuning for your machine
✅ How to deploy to production

Quick Decision: Which Tool to Use?

┌─────────────────────────────────────────┐
│  Want to use AI in your Python code?    │
└────────────┬────────────────────────────┘
             │
             ▼
┌──────────────────────────────────────────┐
│  Building a multi-step AI agent that     │
│  makes decisions and uses tools?         │
└────────────┬─────────────────────────────┘
             │
        YES  │  NO
             │   └──────────────────────┐
             │                          │
             ▼                          ▼
      Use ChatOllama()          Use ollama.chat()
      ✅ For agents             ✅ For simple queries
      ✅ For tools              ✅ For streaming
      ✅ For state mgmt         ✅ For speed
      ✅ For production         ✅ For prototyping

Performance at a Glance

Operation	Time	Notes
ollama.chat() response	15-25ms	Fastest
ChatOllama() response	35-55ms	More features
Streaming first token	5-20ms	Real-time feedback
Tool execution	2-12ms	Overhead varies

Real-world: On a laptop with 8GB RAM, you'll get responses in under 100ms most of the time.

For local AI, this is blazingly fast. (Cloud APIs add 500ms+ of network latency)

Part 1: Simple Queries with `ollama.chat()`

When to use: You just need to ask the AI something and get an answer.

Setup (2 minutes)

First, make sure Ollama is running:

# Terminal 1: Start Ollama
ollama serve

Now you're ready to code.

Your First Query

import ollama

response = ollama.chat(
    model="qwen2.5-coder:latest",
    messages=[
        {"role": "user", "content": "What is 2 + 2?"}
    ]
)

print(response['message']['content'])
# Output: "2 + 2 equals 4"

Streaming (See Responses as They Generate)

Want to see the AI think in real-time?

import ollama

print("AI: ", end="", flush=True)

for chunk in ollama.chat(
    model="qwen2.5-coder:latest",
    messages=[
        {"role": "user", "content": "Write a haiku about code"}
    ],
    stream=True
):
    print(chunk['message']['content'], end="", flush=True)

print()  # Newline at end

Output:

AI: Lines of logic dance,
Bugs and fixes both take turns—
Code shapes the future.

Multi-Turn Conversation (Remember Context)

Ask follow-up questions:

import ollama

messages = []

while True:
    user_input = input("You: ")

    # Add your message
    messages.append({"role": "user", "content": user_input})

    # Get response
    response = ollama.chat(
        model="qwen2.5-coder:latest",
        messages=messages
    )

    ai_response = response['message']['content']
    print(f"\nAI: {ai_response}\n")

    # Add AI's response so it remembers context
    messages.append({"role": "assistant", "content": ai_response})

Try this conversation:

You: What is a lambda function in Python?
AI: A lambda function is a small anonymous function...

You: How is it different from a regular function?
AI: Great question! The key differences are...

Notice how the AI knows you're talking about Python, because it remembers the context.
Once context limit is reached, expect errors to appear.

Part 2: Building AI Agents with `ChatOllama()`

When to use: You're building something more sophisticated—agents that make decisions, use tools, and manage state.

Setup (5 minutes)

pip install langchain-ollama langchain langgraph

Your First Agent

An agent is an AI that can:

✅ Make decisions
✅ Use tools to accomplish tasks
✅ Keep track of conversation state
✅ Handle multiple steps

Let's build one that can tell time:

from langchain_ollama import ChatOllama
from langchain.tools import tool
from langchain.agents import create_agent

# Step 1: Create a tool
@tool
def get_current_time() -> str:
    """Get the current time."""
    from datetime import datetime
    return datetime.now().strftime("%H:%M:%S")

# Step 2: Create the AI
llm = ChatOllama(
    model="qwen2.5-coder:latest",
    temperature=0.0  # Be deterministic
)

# Step 3: Create the agent
agent = create_agent(
    llm,
    tools=[get_current_time],
    system_prompt="You are a helpful time assistant."
)

# Step 4: Use it
result = agent.invoke({
    "messages": [{"role": "user", "content": "What time is it right now?"}]
})

print(result['output'])
# Output: "It is currently 14:23:45"

What just happened?

You asked the agent what time it is
The agent decided it needed to use the get_current_time tool
It called the tool and got the time
It gave you a friendly response

The agent made the decision. You just provided the tools.

Adding Multiple Tools

Tools let your agent accomplish real things:

from langchain.tools import tool

@tool
def add_numbers(a: int, b: int) -> int:
    """Add two numbers together."""
    return a + b

@tool
def multiply_numbers(a: int, b: int) -> int:
    """Multiply two numbers together."""
    return a * b

# Create agent with multiple tools
agent = create_agent(
    llm,
    tools=[add_numbers, multiply_numbers, get_current_time],
    system_prompt="You are a helpful math assistant."
)

# The agent will decide which tool to use
result = agent.invoke({
    "messages": [{"role": "user", "content": "What's 25 * 4?"}]
})

print(result['output'])
# Output: "25 * 4 equals 100"

The agent automatically chose the multiply_numbers tool!
If you need, you can add verbose logging in each of the functions to keep track of which tools were used by the agent. This is also how you protect these tools by creating an input request to confirm the usage of the tool to avoid the agent doing the wrong actions.

Agents that Remember Things

What if you want the agent to remember user preferences or conversation history?

from agent_workspace.hybrid_store import HybridStore

# Create persistent storage
store = HybridStore(
    storage_dir="agent_workspace/storage"
)

# Tool that saves preferences
@tool
def save_preference(key: str, value: str, runtime) -> str:
    """Save a user preference that persists."""
    store = runtime.store
    store.put(("preferences",), key, {"value": value})
    return f"Saved: {key} = {value}"

@tool
def get_preference(key: str, runtime) -> str:
    """Retrieve a saved preference."""
    store = runtime.store
    pref = store.get(("preferences",), key)
    if pref:
        return f"Your {key} is: {pref.value['value']}"
    return "No preference found"

# Create agent WITH persistent storage
agent = create_agent(
    llm,
    tools=[save_preference, get_preference],
    store=store,  # Connect the storage
    system_prompt="You help manage user preferences."
)

# Session 1: Save preference
print("=== Session 1 ===")
result1 = agent.invoke({
    "messages": [{"role": "user", "content": "Remember that my favorite color is blue"}]
})
print(result1['output'])

# Session 2: Retrieve preference (even after restart!)
print("\n=== Session 2 (After Restart) ===")
result2 = agent.invoke({
    "messages": [{"role": "user", "content": "What's my favorite color?"}]
})
print(result2['output'])
# Output: "Your favorite color is: blue"

The magic: Data saved in Session 1 is still there in Session 2, even if you restart your computer! The HybridStore will be available in MagicPythong Library, it is a custom made class to save/restore the runtime store from LangChain to file.

Part 3: Real-World Examples

Example 1: A Personal Code Assistant

from langchain.tools import tool
from langchain.agents import create_agent
from langchain_ollama import ChatOllama

@tool
def check_python_syntax(code: str) -> str:
    """Check if Python code is valid."""
    try:
        compile(code, '<string>', 'exec')
        return "✅ Syntax is valid!"
    except SyntaxError as e:
        return f"❌ Syntax error: {e}"

@tool
def explain_code(code: str) -> str:
    """Provide a simple explanation of what code does."""
    # In a real app, you'd call the LLM here
    return "This code does X, Y, and Z"

llm = ChatOllama(model="qwen2.5-coder:latest", temperature=0.0)

agent = create_agent(
    llm,
    tools=[check_python_syntax, explain_code],
    system_prompt="You are a Python code assistant. Help the user write and understand code."
)

# Usage
code = """
def greet(name):
    print(f"Hello, {name}!")
"""

result = agent.invoke({
    "messages": [{"role": "user", "content": f"Is this Python code valid?\n\n{code}"}]
})

print(result['output'])
# Output: "Yes, this Python code is valid..."

Example 2: A Data Analysis Agent

import json
from langchain.tools import tool
from langchain.agents import create_agent
from langchain_ollama import ChatOllama
from agent_workspace.hybrid_store import HybridStore

# Sample data
SALES_DATA = [
    {"product": "Laptop", "sales": 15},
    {"product": "Phone", "sales": 42},
    {"product": "Tablet", "sales": 28},
    {"product": "Headphones", "sales": 35}
]

@tool
def get_sales_data() -> str:
    """Get the latest sales data."""
    return json.dumps(SALES_DATA)

@tool
def save_report(summary: str, runtime) -> str:
    """Save analysis report."""
    store = runtime.store
    store.put(("reports",), "latest", {"summary": summary})
    return "Report saved!"

@tool
def get_saved_report(runtime) -> str:
    """Retrieve the latest saved report."""
    store = runtime.store
    report = store.get(("reports",), "latest")
    if report:
        return f"Latest report: {report.value['summary']}"
    return "No report found"

llm = ChatOllama(model="qwen2.5-coder:latest", temperature=0.0)
store = HybridStore()

agent = create_agent(
    llm,
    tools=[get_sales_data, save_report, get_saved_report],
    store=store,
    system_prompt="You are a data analyst. Help users understand their sales data."
)

# Usage
result = agent.invoke({
    "messages": [{"role": "user", "content": "Analyze our sales data and give me a summary"}]
})

print(result['output'])

Part 4: Choosing the Right Model

Ollama has different size models. Pick based on your computer:

If you have 4GB or less RAM

Use Qwen2.5-Coder 1.5B

llm = ChatOllama(model="qwen2.5-coder:1.5b")

✅ Fast

⚠️ Less capable

If you have 8GB RAM

Use Qwen2.5-Coder 7B

llm = ChatOllama(model="qwen2.5-coder:7b")

✅ Good balance

✅ Handles most tasks

If you have 16GB+ RAM

Use Qwen3-Coder 30B

llm = ChatOllama(model="qwen3-coder:30b")

✅ Most capable

⚠️ Slower

Pull a model:

ollama pull qwen2.5-coder:7b

Part 5: Tuning Performance

Make responses faster

llm = ChatOllama(
    model="qwen2.5-coder:7b",
    temperature=0.0,      # ← Deterministic (faster)
    num_predict=128,      # ← Shorter responses
)

Make responses more creative

llm = ChatOllama(
    model="qwen2.5-coder:7b",
    temperature=0.7,      # ← More creative
    num_predict=512,      # ← Longer responses
)

Use GPU (if you have NVIDIA)

llm = ChatOllama(
    model="qwen2.5-coder:7b",
    num_gpu=35,           # ← Use GPU layers
)

Part 6: Common Issues & Fixes

Issue 1: "Connection refused"

Problem: Getting an error when trying to use the AI

Fix:

# Terminal 1: Start Ollama
ollama serve

Then run your Python code in a different terminal.

Issue 2: "Model not found"

Problem: Error says the model doesn't exist

Fix:

# Download the model
ollama pull qwen2.5-coder:latest

Issue 3: "Out of memory"

Problem: "CUDA out of memory" or system slows down

Fix: Use a smaller model

# Instead of 32B
llm = ChatOllama(model="qwen2.5-coder:7b")

Issue 4: Slow responses

Problem: Takes too long to get a response

Fix:

llm = ChatOllama(
    model="qwen2.5-coder:1.5b",  # Smaller model
    temperature=0.0,              # Deterministic
    num_predict=128,              # Shorter output
)

Part 7: Next Steps

You now have enough to build:

✅ Chat bots
✅ Code assistants
✅ Data analysis agents
✅ Personal AI assistants

Resources

Ollama: https://ollama.ai
LangChain: https://langchain.com
Qwen2.5-Coder: https://github.com/QwenLM/Qwen

Happy coding! 🚀

Back with another cancerous code block to share

IO_Node — Tue, 25 Nov 2025 02:50:20 +0000

Look at this bad boy I cooked up to extract a folder location from an error handling XD

def extract_cwd(data):
    import re
    match = re.search(r'File "(.*?\.py)", line \d+, in <module>', data)
    if match:
        print(f"Current Working Directory (CWD): {match.group(1)}")
    else:
        print("CWD not found in the traceback string.")
try:
    crash
except Exception as e:
    from traceback import format_exc
    extract_cwd(format_exc())

# Output - :> Current Working Directory (CWD): path/to/script

I also made a smaller version using subprocess, just change cd to pwd if on linux

def extract():
    from subprocess import run
    return run("cd", shell=True, check=True, capture_output=True, text=True, encoding='utf-8')

That is all, thanks for tuning in.

Been a bit eh

IO_Node — Wed, 15 Oct 2025 20:01:41 +0000

Well we all got the news about win10 EOL. I've been tinkering a linux build to see if I switch or if I fight to get win11 offline. I mean if I'm going to fight windows OS, might as well fight a linux kernel instead, at least I know I can win eventually. So far I would only lose access to some games, most of the current software I'm using seems to be available and working. Also started more programming projects as most of them are helper tools to assist me in coding bigger softwares. I need to start learning on how to manage git safely to not expose my account which is why I'm aiming at a linux security approach even though there's more CVEs at the moment. It seems I'm not the only one that are looking for desktop solution in the linux environment. I'm choosing Fedora since it's usually well maintained and I have the most experience using.

Also the last post I wanted to make was about sourcing oneself, taking a breather and learning to view my approach from a back view standpoint. I like writing scripts that are useful but investing a lot of time into creating sofisticated softwares might render me insane overtime. Lots of security prevention, good habits and a decent system to support any endeavors I'm enjoying doing for me and others. I don't have much people reading me here but for those that take the time to read these, thank you and I wish our path might cross one day if ever you enjoy my views on programming and technology.

Created my first bot today

IO_Node — Wed, 03 Sep 2025 19:23:49 +0000

Got asked to create an automated bot using Mastodon APIs so I did :)

I'll say more about it another day but I while creating it I thought about something that lots of people I know get confused: bytes and bits, so I make a short code snippets to convert and showcase the differences.

def bytes_to_bits(byte_count: int) -> int:
    return byte_count * 8

def bits_to_bytes(bit_count: int) -> int:
    # floor division (no half-bytes possible)
    return bit_count // 8

def bytes_to_bits(byte_seq: bytes, sep: str = " ") -> str:
    """
    Convert a sequence of bytes into a string of bits.
    Each byte is 8 bits, padded with leading zeros.

    :param byte_seq: bytes object (b'abc' or b'\xff\x10')
    :param sep: separator string between bytes (default: space)
    :return: bit string (e.g. '01100001 01100010')
    """
    return sep.join(f"{byte:08b}" for byte in byte_seq)


def bits_to_bytes(bit_str: str, sep: str = " ") -> bytes:
    """
    Convert a bit string back into raw bytes.

    :param bit_str: string of bits (with optional separators)
    :param sep: separator used between bytes (default: space)
    :return: bytes object
    """
    # Remove separators if present
    parts = bit_str.split(sep) if sep else [bit_str]
    return bytes(int(part, 2) for part in parts if part)

print(bytes_to_bits(512))      # 4096 bits
print(bits_to_bytes(4096))     # 512 bytes

data = b"A"  # ASCII 65
bitstring = bytes_to_bits(data)
print(bitstring)  # '01000001'

data2 = b"Hi"
print(bytes_to_bits(data2, sep="|"))
# '01001000|01101001'

# Back to bytes
recovered = bits_to_bytes(bitstring)
print(recovered)  # b'A'

recovered2 = bits_to_bytes("01001000|01101001", sep="|")
print(recovered2.decode())  # 'Hi'

Since API calls use network, those are usually stored in byte size chunks and each bit is important. b"string" will create a byte version of that string where each character is a byte. I added a bit separator so each bit value can be used individually if needed. I hope you have fun with binary
~IO

I'm not even sorry for this

IO_Node — Mon, 01 Sep 2025 23:32:08 +0000

verify_params=lambda p:print("Verifying the parameters of the script...") or (lambda: [print(f"Script path: {extract_full_path('python_code_checker',p[0])}"), (lambda lp: lp==2 and (fix_path_from_param(p), (lambda f:(check_outside_cwd(f), (lambda: (f.exists() or (_ for _ in ()).throw(FileNotFoundError(f"File not found: '{p[1]}'"))), (lambda: (lambda c:(lambda: c["config"])(json.load(open(f,'r',encoding='utf-8'))))((lambda: (print('Unrecognized config filename, checking for python script instead.') or (print_analyze_menu(f) if f.parts[-1].endswith('.py') else print('Unrecognized python script file')) or json.load(open(f,'r',encoding='utf-8'))))()) ) )() )() )(extract_full_path('python_code_checker',p[1]))) or (lp==3 and print('This test only supports 1 config argument')) or (lp>3 and print('Final script only supports 2 arguments')) or (lp==1 and (print('Script executed without argument, easter egg triggered'),default_config)) or (lp==0 and print('Error: system is unable to find any active script')) or (lp>0 and default_config)])(len(p)))

yes I figured out how to play golf in python. Enjoy this cringe-fest. 1000 lines scripts? pffft more like 1 line XD

Algorithmic Suggestion Extraction #1

IO_Node — Mon, 01 Sep 2025 18:38:17 +0000

The importance of self-approval

IO_Node — Sun, 31 Aug 2025 21:25:44 +0000

TL/DR: Only how you perceive your work matters really. Don't be scared of learning to find solutions. If you see something missing, it might mean you were meant to create it. Class Dunder tutorial at the end.

I bet most of you here had to go through this type of thought process to motivate you to keep pushing even when everything seems unachievable. Sometime it's because you took on something that was more complex than you previously thought or while fixing an issue, you end up with a bigger problem to figure out than a simple bug fix. Those surprise challenges that appears on the path often drives the best of us to self-torture for not being able to figure it out in a timely manner that prevents peers from pressuring for a solution.

Always remember, you are okay. Not all solution can be found immediately, even if the unrealistic expectation of others are looming over your shoulder. Let them keep expecting unreal results and be disappointed. Did you try to fix it? If the answer if yes then you have more to be proud about it than anyone complaining about any new problems that appears.

Personnally, I'm starting to find that my code_checker project has put me in this situation many times, forcing me to slow down and learn the intricacies of python. I recomfort myself in knowning that no matter what problem I face, there's a solution. Might not be an immediately found solution, but the possibility of a problem being solved is way higher nowadays compared to when I started learning coding in the late 1990.

We are in an era where coding can be as pretty and efficient as it could ever be, we just need to focus on creating it and making it accessible. How many of you have complaints about a specific language just because it's missing parts of another language that you like? I know that I constantly have to pre-patch any language that I want to use to make it behave in a way that feels more comfortable for a HUMAN to use.

I do think we are about to experience a moment in computer science where coding will have two distinct version, the low-level machine coding and the high-level human applications. Although some humans do like to code low-level language, most of the synthax is unreadable without highly advanced knowledge of that language (usually C or Rust) which still would categorize it as more adapted for machine to handle than humans. There's a reason why many of us gives this level of importance to what is arguably and subjectively called clean code.

Although the specifics of clean code can be slightly different between individuals, the overall objective of using clean code should always be the same: easy to read and understand. I always thought of any attempts at recreating an algorithmic synthax as attempting to create clean code. I am currently working on a workaround meant specifically for cleaning and standardizing python class objects usage and output. Here's an example of a big flaw of class object in python; the lack of native support for them:

🟢 Summary

Operation       
Foo + Foo
Normal Class (class Foo)    
❌ TypeError (no __add__)  
With Dunders / Meta
✅ if metaclass defines __add__

Operation
Foo(…) + Foo(…) (instances)
Normal Class (class Foo)    
❌ TypeError (no __add__)  
✅ if instance defines __add__

Operation
Foo[0]
Normal Class (class Foo)    
❌ TypeError (not subscriptable)
With Dunders / Meta 
✅ if metaclass defines __getitem__

Operation
Foo_instance(…)
Normal Class (class Foo)    
❌ TypeError (not callable)
With Dunders / Meta 
✅ if instance defines __call__

So I learned how Python works and most of my software do exactly what I want them to do, that is until I started using objects. Then it became a dunder hunting nightmare as each time I tried to use an object in a new scenario, it would always end up failing because of the lack of support for them.

And thus Magic Pythong was born, an honest attempt at making class objects more usable natively through a simple package/module import. I'm still gathering any possible feedback about already existing libraries that does similar stuff but so far nothing. This specific "patch" is what I will identify officially as an UniversalObject class, a class that has all missing native operation support and it's accessible from the scope it is imported into.

Want to use a boolean check with two class stored value? you now can. Want to addition two int value stored in two objects? you now can. Want to get the type of a value stored into an object? it will now give you the proper type instead of always outputing type. Want to create an actual constant value that is protected? you bet you can now. Why was those options not already available? I have no idea but I bet it has to do with Python Interpreter.

This UniversalObject class is actually ready for use and collaborative work. Before I attempt any opening of my code publicly, I want to learn how to do it safely. Many article I've read about people accidently exposing their API keys because they use vibe coding in their project management. So until I feel comfortable opening it, I'll keep learning how to properly do it and create more workarounds that I want.

This is when I thought about java. Yes java, ugh. So I thought about locking an object for access. It's somewhere in your code but it needs a key to be used. It reminded me of the private / public function system that java supports and felt it could be a great addition to have if ever I wanted to start creating video games with secret levels. This was the birth of my bane; LocalObject.

This is thing is a pain to create, not only is it hard to create the workaround to make class usable natively, adding a lock on each of those workaround to avoid data leak is extremely frustrating. the getattr and setattr dunders just dont want to play nice with me at all and they got me stuck into testing different approach for a whole week.

So more learning it is, decided to get a closer look at them, and again, using my favorite GPT friend to produce me some decent starting points for researching. I'm using these posts to share the data I'm extracting so that if ever you feel it's something you could use to learn, then I'm glad I helped you.

🐍 Python Class Dunder Hacks: A Full Tutorial

Dunder (double underscore) methods are hooks Python calls automatically. They’re not “magic,” but they feel like it because you never call them directly — Python does.

1. Object Lifecycle

These dunders control how objects are created and destroyed.

__new__(cls, *args, **kwargs)
Called before __init__. Returns the actual instance.
Hack: implement singletons or immutable types.

class OnlyOne:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance


__init__(self, ...)
Normal initializer.

__del__(self)
Destructor (called when garbage-collected). Rarely reliable.

2. Attribute Control

These dunders let you intercept attribute access like a proxy.

__getattr__(self, name)
Called when attribute name doesn’t exist.

class Lazy:
    def __getattr__(self, name):
        return f"Generated {name} dynamically"


__getattribute__(self, name)
Called always for every attribute access. (Be careful: must avoid recursion by using object.__getattribute__).

class Spy:
    def __getattribute__(self, name):
        print(f"Accessed {name}")
        return object.__getattribute__(self, name)


__setattr__(self, name, value)
Intercepts obj.attr = value.

class Locked:
    def __setattr__(self, name, value):
        if name.startswith("_"):
            object.__setattr__(self, name, value)
        else:
            raise TypeError("Locked object: cannot set attributes")


__delattr__(self, name)
Called on del obj.attr.

__dir__(self)
Customizes dir(obj) output.

3. Representation & Conversion

These dunders make your objects look nice.

__repr__(self) → unambiguous string (for devs).

__str__(self) → pretty string (for users).

__bytes__(self) → bytes(obj).

__format__(self, spec) → f-string formatting.

class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return f"Person({self.name!r})"
    def __str__(self):
        return self.name

4. Container Emulation

Make objects act like lists, dicts, sets.

__len__(self) → len(obj)

__getitem__(self, key) → obj[key]

__setitem__(self, key, value) → obj[key] = value

__delitem__(self, key) → del obj[key]

__iter__(self) → for x in obj:

__contains__(self, item) → item in obj

class VirtualList:
    def __getitem__(self, idx):
        return idx * 10
    def __len__(self):
        return 999

5. Callable & Context Manager

__call__(self, *args, **kwargs) → make an object act like a function.

class Adder:
    def __call__(self, a, b):
        return a + b


__enter__ / __exit__ → context managers (with statement).

class TempFile:
    def __enter__(self): print("OPEN")
    def __exit__(self, exc_type, exc_val, exc_tb): print("CLOSE")

6. Operator Overloading

Arithmetic dunders let objects behave like numbers.

__add__(self, other) → +

__sub__ → -

__mul__ → *

__truediv__ → /

__floordiv__ → //

__mod__ → %

__pow__ → **

__radd__, __rmul__, etc. → reverse ops

__eq__, __lt__, __gt__, __ne__, etc. → comparisons

__hash__ → hash(obj)

class Vec2:
    def __init__(self, x, y): self.x, self.y = x, y
    def __add__(self, o): return Vec2(self.x+o.x, self.y+o.y)
    def __repr__(self): return f"Vec2({self.x},{self.y})"

7. Class Control

Dunders at the class level.

__class_getitem__(cls, key) → allow generics (MyClass[int]).

__instancecheck__ / __subclasscheck__ → customize isinstance/issubclass.

__init_subclass__ → hook called when subclassing.

__mro_entries__ → control multiple inheritance resolution.

__prepare__ (in metaclasses) → customize class dict before creation.

class Meta(type):
    def __new__(mcls, name, bases, dct):
        print(f"Creating {name}")
        return super().__new__(mcls, name, bases, dct)

class MyClass(metaclass=Meta): pass

8. Pickling & Copying

__getstate__ / __setstate__ → for pickle.

__reduce__ → advanced pickling control.

__copy__, __deepcopy__ → for copy module.

9. Async & Awaitable

__await__ → await obj

__aiter__, __anext__ → async iteration

__aenter__, __aexit__ → async context manager.

class AsyncCounter:
    def __aiter__(self): self.i = 0; return self
    async def __anext__(self):
        self.i += 1
        if self.i > 3: raise StopAsyncIteration
        return self.i

🧨 Real Hacks You Can Pull Off

Sealed objects → lock attributes with __setattr__.

Lazy loading → __getattr__ to fetch things on demand.

Immutable data classes → override __setattr__ to block changes.

Fluent DSLs → __call__ + __getitem__ to make objects behave like mini-languages.

Proxy objects → wrap APIs with logging via __getattribute__.

Sandboxing → disallow dangerous attributes dynamically.

This is where I'm currently working on, learning those dunder hacks properly so I can start working together with the agent on the fix. I usually work in the testing lab instead of assisting the agent and simply do vibe coding cleanup once all the premade test passes. This is how I could identify that the locking mechanism was being skipped instead of refactored.

They can't always be good days

IO_Node — Sun, 31 Aug 2025 15:28:30 +0000

It seems I was cheering a bit too early my success haha. It seems the AI agent decided to simply bypass the locking mechanism instead of making it work with constant values. Tool is running with insufficient ressources so it takes full days for it to execute anything. I love this setup where the agent is slow as it forces me to work manually as well. I strongly suggest it to any begginers, tandem work on dual project, one is manual and the other is slow but automatic. While the agent is finishing up the class lock, I'll work to figure out how class inheritance / metaclass fed to it can be detected or backtracked for guidance purposes. Didn't even knew class had this system so I'm still exploring and might be doing this for the whole day.

🟦 1. Basic Classes

A class in Python is just a template for creating objects.

class Animal:
    def speak(self):
        return "some sound"

a = Animal()
print(a.speak())  # "some sound"

🟦 2. Inheritance (Re-using / Extending Classes)

Inheritance means one class reuses or extends another.

class Dog(Animal):   # Dog inherits from Animal
    def speak(self):
        return "woof!"


Dog gets everything from Animal.

If you don’t override, it just uses the parent’s methods.

If you override (def speak), your new version is used.

d = Dog()
print(d.speak())  # "woof!"

🔹 Multiple Inheritance

Python allows a class to inherit from multiple classes.

class Walker:
    def move(self):
        return "walking"

class Swimmer:
    def move(self):
        return "swimming"

class Duck(Walker, Swimmer):
    pass


Now, which move() does Duck use?
Python resolves it using the Method Resolution Order (MRO) → a deterministic order of lookup.

duck = Duck()
print(duck.move())  
# "walking", because Walker is listed first
print(Duck.__mro__)  
# (<class '__main__.Duck'>, <class '__main__.Walker'>, <class '__main__.Swimmer'>, <class 'object'>)

🟦 3. Constructors (__init__)

When you do obj = ClassName(...), Python calls the class’s __init__ method.

Parent constructors can be called with super().

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # call parent __init__
        self.breed = breed

d = Dog("Rex", "Labrador")
print(d.name, d.breed)  # Rex Labrador

🟦 4. Metaclasses (Classes of Classes)

Now the tricky part:

In Python, everything is an object, even classes themselves.

If objects are created by classes… what creates classes?
→ The answer: a metaclass.

By default, Python uses type as the metaclass.

# "Animal" is itself an object created by "type"
print(type(Animal))  # <class 'type'>


So:

Normal objects are instances of a class.

Classes are instances of a metaclass (usually type).

🔹 Custom Metaclass

You can define your own metaclass to control how classes are built.

class Meta(type):  # inherit from 'type'
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass


Output:

Creating class MyClass


Here, Meta.__new__ runs at the moment the class is defined, not when it’s instantiated.
Metaclasses are like blueprints for classes.

🟦 5. When to Use Inheritance vs Metaclasses

Inheritance = organize and reuse code between objects.

Metaclasses = control or modify how classes themselves behave (rare, advanced use cases).

Example metaclass usage:

Enforcing coding standards (e.g., all methods must be lowercase).

Auto-registering classes into a plugin system.

Automatically adding methods/attributes to classes.

🟦 6. Summary

Inheritance:

Reuse code between classes.

Supports multiple parents.

Follows MRO for lookup.

Constructors (__init__):

Define what parameters a class instance takes.

super() allows chaining to parent constructors.

Metaclasses:

Classes are objects, created by a metaclass (type by default).

Custom metaclasses let you intercept or modify class creation.

Powerful, but niche — usually not needed unless building frameworks/libraries.

Wasn't too sure about how super() and metaclass usage so I keep going:

🟦 1. type as “the metaclass of metaclasses”

In Python:

Normally, when you call a class like Dog("Rex"), what happens is not a simple function call.

Internally, Python does something like this:

obj = Dog.__call__(*args, **kwargs)


But Dog.__call__ comes from its metaclass (by default, type).

So the whole flow is:

Dog(...) 
→ Dog.__class__ is type
→ type.__call__(Dog, *args, **kwargs)
→ Dog.__new__(Dog, *args, **kwargs)  # allocate memory
→ Dog.__init__(self, *args, **kwargs) # initialize fields
→ return instance

🟦 2. So what does super() really do?

super() doesn’t mean “the parent”. It means:
“go to the next class in the MRO after my current class.”

Example:

class A:
    def greet(self):
        print("A")

class B(A):
    def greet(self):
        print("B")
        super().greet()

class C(A):
    def greet(self):
        print("C")
        super().greet()

class D(B, C):
    def greet(self):
        print("D")
        super().greet()


MRO:

print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)


Execution:

D().greet()
# D
# B
# C
# A


Notice how super() followed the MRO, not just “parent”.

🟦 3. Metaclasses in Action

If you give a class a metaclass=Meta, then the creation of the class object itself is intercepted.

class Meta(type):
    def __call__(cls, *args, **kwargs):
        print(f"Creating instance of {cls.__name__}")
        return super().__call__(*args, **kwargs)

class MyClass(metaclass=Meta):
    def __init__(self, x):
        self.x = x


Now:

obj = MyClass(42)


Execution order:

Meta.__call__(MyClass, 42) runs

Inside, super().__call__ delegates to type.__call__

Which calls MyClass.__new__

Then MyClass.__init__

🟦 4. Why it looks “hardcoded”

Yes — you must declare metaclass=Meta because only one metaclass controls class creation.

But note:

class Foo: pass → uses type automatically.

class Foo(metaclass=Meta): pass → uses your Meta.

And since metaclasses are themselves subclasses of type, you can extend the logic of type.__call__, type.__new__, etc.

🟦 5. Analogy

Think of it like a factory system:

Objects = Products (instances you actually use).

Classes = Factories (blueprints for products).

Metaclasses = Factory Designers (blueprints for factories).

When you do:

p = Product()


it’s like:

Call the Factory Designer (metaclass) to create a Factory (class) → happens once at definition.

Call the Factory (class) to produce a Product (object) → happens each time you instantiate.

So here's a quick look under the hood of my learning process using GPT. I also sometime use Gemini through google search but it's usually for code snippets to validate syntax more than to learn new stuff. I hope you learned something as well. This learning experience opened my eyes to the power of Method Resolution Order (MRO).

Use Class.mro to walk inheritance.
If unresolved locally, parse imports to resolve base classes.
Once you have class definitions, check init / new signatures → collect their parameter requirements.
Detect metaclass= as the “entry point” to type class detection and can only have one declaration.

Surprise Breakthrough

IO_Node — Sun, 31 Aug 2025 01:39:56 +0000

As mentioned in my previous post, I've been working to create a locking mechanism for a class in python and it seems the test initially made for synthax ruling is now passing all the tests!! Here's the output results of using both the UniversalObject and LocalObject classes:

=== UniversalObject Examples ===
Dict creation (normal): {'name': 'John', 'age': 30}
Index keys: ['name', 'age']
Name from index: John

Dict creation (constant): {'name': 'John', 'age': 30}
Index keys: ['name', 'age']
Name from index (should be tuple): ('John',)

List creation (normal): [1, 2, 3]
Index keys: ['arg_0', 'arg_1', 'arg_2']
arg_0 from index: 1

List creation (constant): [1, 2, 3]
Index keys: ['const_0', 'const_1', 'const_2']
const_0 from index (should be tuple): (1,)

Single value (normal): hello
Index keys: ['arg_0']

Single value (constant): hello
Index keys: ['arg_0']
arg_0 from index (should be tuple): ('hello',)

=== Demonstrating Parent Display ===
With show_parent=True: {'test': 'value'}

=== LocalObject Examples ===
Dict creation (normal): <LocalObject:locked>
Index keys: ['name', 'age']

Dict creation (constant): <LocalObject:locked>
Index keys: ['name', 'age']
name from index (should be tuple): ('Jane',)

List creation (normal): <LocalObject:locked>
Index keys: ['arg_0', 'arg_1', 'arg_2']

List creation (constant): <LocalObject:locked>
Index keys: ['const_0', 'const_1', 'const_2']

Single value (normal): <LocalObject:locked>
Index keys: ['arg_0']

Single value (constant): <LocalObject:locked>
Index keys: ['arg_0']
arg_0 from index (should be tuple): ('world',)

=== Demonstrating Constant Protection ===
Constant values are stored as single-element tuples:
u4.const_0 = 1
type(u4.const_0) = <class 'int'>
l4.const_0 = 10
type(l4.const_0) = <class 'int'>

=== Demonstrating LocalObject Locking Behavior ===
Locked LocalObject created:
After unlocking, l7.locked = True

Not only does the naming is standardized, it support real constant / variables and all logical / mathematical operations as if they are regular container instead of class objects. It also has a dict index of all value fed to the class for easy access (.arg_index).

Step 1 completed, will now work on the multi-lock system using conditions now that I can do normal boolean checks with the objects XD This type() check on constants that gives back the actual type of the value stored instead of always giving a tuple is chef kiss.

If you are interested in my Magic Pythong journey, feel free to drop a comment about what you would like to see implemented in the future public repo.

Python Journey Log #1

IO_Node — Sat, 30 Aug 2025 17:38:56 +0000

Opening:

Coming from a perl / wscript background, I'm currently focusing on learning and applying my previous application (RAII/SRP) to python.

Projects Resume:

Music generator that generates visuals using shaders.

Started well, most of the musical theory is fairly accessible through libraries like music21, numpy and midiutil. I can currently generate basic midi song loops. the threejs part for shader support isnt started yet. currently on pause as i need to learn more about python before i can combine other languages.

Python tutorials, also doubles as a code snippet cheat sheet.

Ongoing progress, currently have some pretty decent starting subjects:

* globals() manipulation and importance
* locals() manipulation and importance
* regex filtering (I hate this synthax, can't wait to do linux python and use grep)
* logical operators for variables and objects
* keywords and built-in functions
* IO and file manipulation
* assembly / source extraction
* classes and custom dunder (__init__, __str__, etc.)
* error handling and bubbling of raise
* multiprocessing and GIL
* matplotlib visuals and application

If you have any good subject suggestions, I'm all ears. As you saw, I'm not affraid do dig deep. The more I'm digging, the more I feel python needs my magic touch. Keep reading to see what I mean :)

Python Code Checker!

Hell yeah I'm going to try this. I can now successfully extract arguments fed into my script from the console, understand what type of argument they are, send them properly toward the right function while preventing any violation during input. I'm pretty happy with the efforts I've put in this one.

uses AST to create a usable structure
use logic and regex to identify multiple pieces of code (functions, classes, variables, arguments/parameters of functions, loops, conditions, errors, docstrings, dead values, and still adding more!)
supports both user input and dynamic console arguments.
produce a report once completed (currently broken and under maintenance)
currently working on dynamic import detections and variable backtracking.
plan of supporting automatic code fixes, code suggestion for issues found, support for linux and configuration editor (config edit almost done)

My favorite project so far as I'm learning a lot of stuff doing this, exploring the most system heavy libraries and how to safely travel through them, wouldnt want to recursively delete all my project XD

Magic Pythong Package

So here's why I said python needs some magic. I currently have as an objective to focus on Langchain application in Python.

The first thing I identified is the lack of actual constant values so my first "magic" is to use tuple type even with single values to protect anything that I consider a constant in my code.
The second thing I identified is class manipulation through logical operator is a cancer. It needs to be chirurgically removed, which leads to the next "magic": Multi-Locked, Universal and standardized classes.
While looking into memory manipulation, I started working on what I would consider my 3rd "magic" which is a 100% dynamic module import with an automatic cleaner (I would consider the auto clean the 4th "magic"). Everyone is using globals for import to simplify their usage but that's not tolerated for me. imports should be only used in localized scopes and immediately flushed afterward. You only strategize your imports scope after you are done with the complete structure. This is to plan for really memory intense workflows.

This is what I would call my MPythong, this is purely personal in nature and is something I would be interested in making publicly available for everyone to use if interest for it catches. It might already exist in some form in another library but I didn't found it yet.

That gives a full round tour of all my current python projects, what I'm aiming them towards and some opening for collaborations for those interested.

The picture was generated using a special proprietary tool called synthopixel. I have full rights on all content I use.

Forem: IO_Node

Hello again, here's a LangChain Ollama helper sheet :)

LangChain + Ollama: A Practical Guide to Building AI Agents with Python

What You'll Learn

Quick Decision: Which Tool to Use?

Performance at a Glance

Part 1: Simple Queries with ollama.chat()

Setup (2 minutes)

Your First Query

Streaming (See Responses as They Generate)

Multi-Turn Conversation (Remember Context)

Part 2: Building AI Agents with ChatOllama()

Setup (5 minutes)

Your First Agent

Adding Multiple Tools

Agents that Remember Things

Part 3: Real-World Examples

Example 1: A Personal Code Assistant

Example 2: A Data Analysis Agent

Part 4: Choosing the Right Model

If you have 4GB or less RAM

If you have 8GB RAM

If you have 16GB+ RAM

Part 5: Tuning Performance

Make responses faster

Make responses more creative

Use GPU (if you have NVIDIA)

Part 6: Common Issues & Fixes

Issue 1: "Connection refused"

Issue 2: "Model not found"

Issue 3: "Out of memory"

Issue 4: Slow responses

Part 7: Next Steps

Resources

Back with another cancerous code block to share

Been a bit eh

Created my first bot today

I'm not even sorry for this

Algorithmic Suggestion Extraction #1

The importance of self-approval

They can't always be good days

Surprise Breakthrough

Python Journey Log #1

Part 1: Simple Queries with `ollama.chat()`

Part 2: Building AI Agents with `ChatOllama()`