Add initial implementation of chat application with required dependencies

- Created requirements.txt for package dependencies
- Implemented main run logic in run.py
- Defined ChatSession class in chat.py for managing conversations
- Added configuration settings in config.py
- Implemented logging functionality in log.py
- Defined message schema in schema.py
- Added utility function for addition in tools.py

requirements.txt

@@ -0,0 +1,2 @@
+colorlog
+ollama

run.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import asyncio
+
+from src.chat import ChatSession
+
+
+async def _main() -> None:
+    chat = ChatSession()
+    answer = await chat.chat("What is 10 + 23?")
+    print("\n>>>", answer)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(_main())
+    except KeyboardInterrupt:
+        pass

src/__init__.py

@@ -0,0 +1,4 @@
+from .chat import ChatSession
+from .tools import add_two_numbers
+
+__all__: list[str] = ["ChatSession", "add_two_numbers"]

src/chat.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import List
+
+from ollama import AsyncClient, ChatResponse
+
+from .config import MAX_TOOL_CALL_DEPTH, MODEL_NAME, OLLAMA_HOST
+from .log import get_logger
+from .schema import Msg
+from .tools import add_two_numbers
+
+_LOG = get_logger(__name__)
+
+
+class ChatSession:
+    def __init__(self, host: str = OLLAMA_HOST, model: str = MODEL_NAME) -> None:
+        self._client = AsyncClient(host=host)
+        self._model = model
+
+    async def __aenter__(self) -> "ChatSession":
+        return self
+
+    async def ask(self, messages: List[Msg], *, think: bool = True) -> ChatResponse:
+        return await self._client.chat(
+            self._model,
+            messages=messages,
+            think=think,
+            tools=[add_two_numbers],
+        )
+
+    async def _handle_tool_calls(
+        self,
+        messages: List[Msg],
+        response: ChatResponse,
+        depth: int = 0,
+    ) -> ChatResponse:
+        if depth >= MAX_TOOL_CALL_DEPTH or not response.message.tool_calls:
+            return response
+
+        for call in response.message.tool_calls:
+            if call.function.name == "add_two_numbers":
+                result = add_two_numbers(**call.function.arguments)
+                messages.append(
+                    {
+                        "role": "tool",
+                        "name": call.function.name,
+                        "content": str(result),
+                    }
+                )
+                nxt = await self.ask(messages, think=True)
+                return await self._handle_tool_calls(messages, nxt, depth + 1)
+
+        return response
+
+    async def chat(self, prompt: str) -> str:
+        messages: List[Msg] = [{"role": "user", "content": prompt}]
+        response = await self.ask(messages)
+        messages.append(response.message.model_dump())
+
+        _LOG.info("Thinking:\n%s", response.message.thinking or "<no thinking trace>")
+
+        final_resp = await self._handle_tool_calls(messages, response)
+        return final_resp.message.content

src/config.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+import os
+from typing import Final
+
+MODEL_NAME: Final[str] = os.getenv("OLLAMA_MODEL", "qwen3")
+OLLAMA_HOST: Final[str] = os.getenv("OLLAMA_HOST", "http://localhost:11434")
+MAX_TOOL_CALL_DEPTH: Final[int] = 5

src/log.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import logging
+from typing import Final
+
+from colorama import Fore, Style, init as colorama_init
+
+__all__: Final[list[str]] = ["get_logger"]
+
+
+class _ColourFormatter(logging.Formatter):
+    _COLOUR_FOR_LEVEL = {
+        logging.DEBUG: Fore.CYAN,
+        logging.INFO: Fore.GREEN,
+        logging.WARNING: Fore.YELLOW,
+        logging.ERROR: Fore.RED,
+        logging.CRITICAL: Fore.MAGENTA,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:  # noqa: D401
+        colour = self._COLOUR_FOR_LEVEL.get(record.levelno, "")
+        return f"{colour}{super().format(record)}{Style.RESET_ALL}"
+
+
+def get_logger(name: str | None = None, level: int = logging.INFO) -> logging.Logger:
+    colorama_init()
+    handler = logging.StreamHandler()
+    handler.setFormatter(_ColourFormatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s"))
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    logger.handlers.clear()
+    logger.addHandler(handler)
+    return logger

src/schema.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import List, Literal, Optional, TypedDict
+
+from ollama import Message
+
+
+class Msg(TypedDict, total=False):
+    role: Literal["user", "assistant", "tool"]
+    content: str
+    name: Optional[str]
+    tool_calls: Optional[List[Message.ToolCall]]

src/tools.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+__all__: list[str] = ["add_two_numbers"]
+
+
+def add_two_numbers(a: int, b: int) -> int:  # noqa: D401
+    """Add two numbers together.
+
+    Args:
+        a (int): First number to add.
+        b (int): Second number to add.
+
+    Returns:
+        int: The sum of the two numbers.
+    """
+    return a + b