# What Libraries Are Used for Model Implementation in AI Berkshire?

> Discover AI Berkshire's unique approach to model implementation. Learn how it bypasses traditional libraries like PyTorch and TensorFlow, leveraging Claude Code for AI operations.

- Repository: [Xbt Lin/ai-berkshire](https://github.com/xbtlin/ai-berkshire)
- Tags: deep-dive
- Published: 2026-07-09

---

**AI Berkshire does not import traditional machine learning libraries such as PyTorch, TensorFlow, or Transformers; instead, it delegates all language model operations to the Claude Code environment powered by Anthropic's Claude model.**

The AI Berkshire repository (xbtlin/ai-berkshire) adopts a serverless architecture for model implementation. Rather than bundling Python LLM libraries directly into its codebase, the project relies on the Claude Code runtime to interpret and execute its skill-based workflows. This design pattern keeps the repository focused on data orchestration while leveraging external AI services for inference.

## The Claude Code Architecture

AI Berkshire implements its AI capabilities through the **Claude Code** environment rather than local model libraries. According to the [`AGENTS.md`](https://github.com/xbtlin/ai-berkshire/blob/main/AGENTS.md) file, the repository treats `skills/*.md` files as canonical workflow sources that define slash-command style entry points. These markdown-based skills are interpreted by the Claude runtime, eliminating the need for embedded model weights or inference code.

### Skill-Based Model Execution

The model implementation relies on declarative skill definitions stored in the `skills/` directory. For example, [`skills/investment-research.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/investment-research.md) serves as a command definition that the Claude Code environment processes. Unlike traditional implementations that might import `langchain` or `openai` Python packages, these markdown files contain no executable code and instead rely on the external Claude service to handle natural language processing and generation.

## Python Dependencies and Utilities

While the repository lacks ML libraries, it contains Python utilities for data handling and web automation. These modules use standard libraries and browser automation tools, keeping dependencies lightweight and focused on data acquisition rather than model inference.

### Core Imports in Data Tools

The Python tools in the repository demonstrate the absence of LLM-related imports. In [`tools/xueqiu_scraper.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/xueqiu_scraper.py), the import statements include only standard library modules and web automation utilities:

```python

# tools/xueqiu_scraper.py

import argparse
import asyncio
import json
import os
import random
import re
from datetime import datetime
from pathlib import Path
from playwright.async_api import async_playwright

```

Notice the complete absence of `torch`, `tensorflow`, `transformers`, `langchain`, or `openai` imports. The `playwright.async_api` import supports web scraping functionality, not language model operations.

## Evidence from Source Files

A comprehensive analysis of the repository confirms no traditional model implementation libraries are present.

### AGENTS.md and Compatibility Rules

The [`AGENTS.md`](https://github.com/xbtlin/ai-berkshire/blob/main/AGENTS.md) file establishes the project's compatibility model, specifying support for both Claude Code and Codex workflows. This documentation confirms that the repository delegates AI operations to these external environments rather than implementing them locally. The file explicitly references Claude Code's slash-command system as the primary interface for model interactions.

### ai_CLAUDE.md Integration

The [`ai_CLAUDE.md`](https://github.com/xbtlin/ai-berkshire/blob/main/ai_CLAUDE.md) file contains integration instructions for the Claude environment. Unlike typical AI projects that might document API keys for OpenAI or import statements for Hugging Face Transformers, this file focuses on Claude Code-specific configurations. The documentation highlights the project's reliance on Anthropic's service rather than local model implementations.

## Summary

- **AI Berkshire uses Claude Code** (Anthropic's Claude model) as its sole language model implementation, with no embedded Python ML libraries.
- **Zero imports** of `torch`, `tensorflow`, `transformers`, `langchain`, or `openai` exist in the repository codebase.
- **Python modules** like [`tools/xueqiu_scraper.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/xueqiu_scraper.py) depend exclusively on standard libraries (`json`, `os`, `argparse`) and web automation tools (`playwright`).
- **Skills are defined** in markdown files (e.g., [`skills/investment-research.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/investment-research.md)) and interpreted by the external Claude runtime.
- **Architecture** follows a skill-based command pattern documented in [`AGENTS.md`](https://github.com/xbtlin/ai-berkshire/blob/main/AGENTS.md) and [`ai_CLAUDE.md`](https://github.com/xbtlin/ai-berkshire/blob/main/ai_CLAUDE.md).

## Frequently Asked Questions

### Does AI Berkshire use LangChain for model implementation?

No, AI Berkshire does not use LangChain. Source code searches for "langchain" return no matches, and the repository architecture bypasses orchestration frameworks entirely. Instead, the project relies on Claude Code's native skill system to manage AI workflows.

### What Python packages does AI Berkshire actually use?

The repository uses standard Python libraries (`json`, `os`, `argparse`, `asyncio`) alongside web automation tools like Playwright. For instance, [`tools/xueqiu_scraper.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/xueqiu_scraper.py) imports `playwright.async_api` for browser automation but contains no dependencies for language model APIs or local inference.

### How does AI Berkshire access AI models without API libraries?

AI Berkshire accesses AI capabilities through the Claude Code environment, which provides the Claude model as an external service. Skills defined in markdown files (such as [`skills/investment-research.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/investment-research.md)) are parsed and executed by this runtime, removing the need for direct API integration or Python bindings in the source code.

### Is there any plan to add local LLM libraries to the repository?

Based on the current codebase structure and documentation in [`AGENTS.md`](https://github.com/xbtlin/ai-berkshire/blob/main/AGENTS.md), the project maintains a strict separation between local utilities and model inference. There is no evidence of planned integration for local libraries like PyTorch or Transformers, as the design philosophy explicitly favors external AI services via Claude Code.