ATLAS-AI is an open-source fine-tuned language model that teaches the causal evolution of artificial intelligence. It understands not just how AI systems work, but why they were necessary and what problems they solved.
Problem: AI education is fragmented. Engineers learn to use frameworks without understanding the causal chains that made them necessary.
Solution: ATLAS-AI is trained on the ATLAS curriculum—a structured causal graph of AI's intellectual evolution—to answer deep questions about AI development.
# 1. Install
pip install -r requirements.txt
# 2. Generate example data and train
python scripts/quickstart.py
# 3. Run inference
python scripts/infer.py \
--model-path ./models/atlas_ai_v1 \
--question "Why did neural networks require gradient descent?"ATLAS-AI can answer three types of questions:
Q: Why was deep learning necessary after early neural networks?
A: Deep learning was necessary because...
Q: Explain the causal chain to Transformers
A: Transformers required...
Q: What's the next likely breakthrough in AI?
A: Given current constraints, the next breakthrough will likely...
- Fine-tuned on causal knowledge graphs — Not just statistical patterns
- Production-ready inference — Python API, FastAPI server, CLI tools
- Parameter-efficient — LoRA (10x fewer parameters than full fine-tuning)
- Open source — Weights and training data released on Hugging Face Hub
- Extensible — Create custom causal graphs for your domain
- Python 3.8+
- 16GB+ RAM (8GB GPU strongly recommended)
# Clone repository
git clone https://github.com/altruva-lab/atlas-ai.git
cd atlas-ai
# Create virtual environment
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
# Install dependencies
pip install -r requirements.txt# Create example causal graph with AI concepts
python scripts/generate_example_graph.py
# Generate training dataset from graph
python scripts/quickstart.pypython scripts/train.py \
--graph-path data/example_causal_graph.json \
--model-name meta-llama/Llama-2-7b \
--output-dir ./models/atlas_ai_v1 \
--epochs 3 \
--use-lorafrom atlas_ai import CausalReasoner
# Load fine-tuned model
model = CausalReasoner.from_pretrained("./models/atlas_ai_v1")
# Ask questions
answer = model.reason("Why did attention mechanisms become necessary?")
print(answer)
# Explain causal chains
explanation = model.explain_causal_chain("Transformers")
print(explanation)
# Predict breakthroughs
prediction = model.predict_next_breakthrough(
"LLMs are powerful but lack long-term planning"
)
print(prediction)python -c "from atlas_ai.api import run_api_server; \
run_api_server('./models/atlas_ai_v1')"
# API at http://localhost:8000
# Docs at http://localhost:8000/docs| Document | Purpose |
|---|---|
| Getting Started | Setup and basic usage |
| ATLAS-AI Guide | Full feature overview |
| Architecture | System design and components |
| LINEAGE Guide | AI curriculum reference |
| Installation | Advanced setup options |
| Ecosystem | ATLAS ecosystem overview |
atlas_ai/
├── data/ # Data structures and utilities
│ ├── causal_graph.py # CausalGraph, CausalNode, CausalEdge
│ └── dataset.py # Dataset builders and loaders
├── fine_tuning/ # Fine-tuning pipeline
│ └── trainer.py # FineTuningConfig, AtlasAIFineTuner
├── models/ # Inference layer
│ └── causal_reasoner.py # CausalReasoner (main inference API)
├── utils/ # Utilities and evaluation
│ └── evaluation.py # Causal reasoning metrics
└── api.py # FastAPI inference server
scripts/
├── train.py # Fine-tuning script
├── infer.py # Inference CLI
├── evaluate.py # Evaluation script
├── generate_example_graph.py # Generate example data
└── quickstart.py # Quick setup guide
examples/
└── usage_examples.py # Comprehensive usage examples
tests/
└── test_atlas_ai.py # Unit and integration tests
docs/
├── ATLAS_AI_GETTING_STARTED.md # Getting started
├── ATLAS_AI_GUIDE.md # Full guide
├── ARCHITECTURE.md # System architecture
├── LINEAGE_GUIDE.md # ATLAS curriculum
└── ... # Other documentation
A directed acyclic graph representing AI evolution:
- Nodes: Concepts (Neural Networks, Transformers, etc.)
- Edges: Relationships (prerequisite, enables, replaces, etc.)
- Metadata: Impact level, era, key papers, researchers
Automatically generates diverse training examples:
- "Why" questions explaining necessity
- Prerequisite questions listing required knowledge
- Enablement questions describing consequences
- Breakthrough prediction questions
Trains base model (Llama, Mistral, etc.) on causal reasoning:
- Uses LoRA for parameter efficiency
- Supports mixed precision training
- Integrates with Hugging Face ecosystem
Multiple interfaces for using the model:
- Python API (CausalReasoner class)
- FastAPI server with REST endpoints
- CLI tools (infer.py, etc.)
from atlas_ai import CausalGraph
graph = CausalGraph.from_json("data/causal_graph.json")
# Query relationships
prerequisites = graph.get_prerequisites("deep_learning")
enabled = graph.get_enables("neural_networks")
# Find causal paths
path = graph.get_causal_path("mathematics", "transformers")from atlas_ai import CausalReasoner
model = CausalReasoner.from_pretrained(model_path)
# Answer questions
answer = model.reason(question)
answer = model.explain_causal_chain(concept)
answer = model.answer_why_question(topic)
answer = model.predict_next_breakthrough(state)from atlas_ai import CausalGraph, CausalDatasetBuilder
graph = CausalGraph.from_json("data/causal_graph.json")
builder = CausalDatasetBuilder(graph)
dataset = builder.build_full_dataset()| Model | Size | Speed | Memory | Reasoning |
|---|---|---|---|---|
| Mistral 7B | 7B | ⚡⚡⚡ | 14GB | ⭐⭐⭐ |
| Llama-2 7B | 7B | ⭐⭐ | 16GB | ⭐⭐⭐ |
| Llama-2 13B | 13B | ⭐⭐ | 28GB | ⭐⭐⭐⭐ |
| Llama-2 70B | 70B | ⭐ | 140GB | ⭐⭐⭐⭐⭐ |
- LINEAGE — The AI curriculum powering ATLAS-AI
- ATLAS-SDK — System generation from causal understanding
- LAEM Institute — Educational mission for Talents.
Contributions welcome! Areas of focus:
- New causal graph datasets
- Improved evaluation metrics
- Benchmark datasets
- Documentation and examples
- Production deployment patterns
See CONTRIBUTING.md for guidelines.
Apache License 2.0 - See LICENSE
- Issues: GitHub Issues
- Discussions: GitHub Discussions
- Twitter: @ennas_de
- Email: dev.abdulhakeem@gmail.com
- ATLAS curriculum developed by Abdulhakeem Muhammed and LAEM Institute
- Fine-tuning implementation based on Hugging Face Transformers
- Inspired by the open source AI community
- Core data structures and causal graphs
- Dataset generation pipeline
- Fine-tuning trainer with LoRA
- Inference API (Python + REST)
- Evaluation metrics
- Multi-model ensemble support
- Production deployment guide
- Integration with ATLAS-SDK
- Benchmark datasets
- Advanced reasoning capabilities
If you use ATLAS-AI in your research or project, please cite:
@software{atlas_ai_2026,
title={ATLAS-AI: Fine-Tuned Causal Reasoning Engine for AI Evolution},
author={Muhammed, Abdulhakeem and Altruva Lab},
year={2026},
url={https://github.com/altruva-lab/atlas-ai}
}Built with ❤️ for the Global South's AI talent.
ATLAS consists of two complementary, independently-maintained projects:
| ATLAS-AI | ATLAS-SDK | |
|---|---|---|
| Purpose | Learn the "why" | Build the "how" |
| Type | Fine-tuned Model | System Generator |
| Users | Students, Educators | Engineers, Architects |
| Org | Altruva Lab | Altruva Group |
Vision: AI systems should be built on causal understanding, not mere pattern recognition.
We welcome contributions! Please see CONTRIBUTING.md for guidelines.
This project is licensed under the Apache License 2.0.
ATLAS-AI is maintained by the Altruva Lab team. For questions or collaboration:
- 📧 Email: dev.abdulhakeem@gmail.com
- 🤝 GitHub: altruva-lab
Part of the ATLAS Ecosystem — Grounding AI in Causal Understanding