#!/usr/bin/env python3
import os
import re
import streamlit as st
import streamlit.components.v1 as components
from urllib.parse import quote
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import base64
import glob
import time
# Page Configuration
st.set_page_config(
page_title="AI Knowledge Tree Builder ๐๐ฟ",
page_icon="๐ณโจ",
layout="wide",
initial_sidebar_state="auto",
)
# Predefined Knowledge Trees
trees = {
"ML Engineering": """
0. ML Engineering ๐
1. Data Preparation
- Load Data ๐
- Preprocess Data ๐ ๏ธ
2. Model Building
- Train Model ๐ค
- Evaluate Model ๐
3. Deployment
- Deploy Model ๐
""",
"Health": """
0. Health and Wellness ๐ฟ
1. Physical Health
- Exercise ๐๏ธ
- Nutrition ๐
2. Mental Health
- Meditation ๐ง
- Therapy ๐๏ธ
""",
}
# Project Seeds
project_seeds = {
"Code Project": """
0. Code Project ๐
1. app.py ๐
2. requirements.txt ๐ฆ
3. README.md ๐
""",
"Papers Project": """
0. Papers Project ๐
1. markdown ๐
2. mermaid ๐ผ๏ธ
3. huggingface.co ๐ค
""",
"AI Project": """
0. AI Project ๐ค
1. Streamlit Torch Transformers
- Streamlit ๐
- Torch ๐ฅ
- Transformers ๐ค
2. DistillKit MergeKit Spectrum
- DistillKit ๐งช
- MergeKit ๐
- Spectrum ๐
3. Transformers Diffusers Datasets
- Transformers ๐ค
- Diffusers ๐จ
- Datasets ๐
""",
}
# Utility Functions
def sanitize_label(label):
"""Remove invalid characters for Mermaid labels."""
return re.sub(r'[^\w\s-]', '', label).replace(' ', '_')
def sanitize_filename(label):
"""Make a valid filename from a label."""
return re.sub(r'[^\w\s-]', '', label).replace(' ', '_')
def parse_outline_to_mermaid(outline_text, search_agent):
"""Convert tree outline to Mermaid syntax with clickable nodes."""
lines = outline_text.strip().split('\n')
nodes, edges, clicks, stack = [], [], [], []
for line in lines:
indent = len(line) - len(line.lstrip())
level = indent // 4
label = re.sub(r'^[#*\->\d\.\s]+', '', line.strip())
if label:
node_id = f"N{len(nodes)}"
sanitized_label = sanitize_label(label)
nodes.append(f'{node_id}["{label}"]')
search_url = search_urls[search_agent](label)
clicks.append(f'click {node_id} "{search_url}" _blank')
if stack:
parent_level = stack[-1][0]
if level > parent_level:
edges.append(f"{stack[-1][1]} --> {node_id}")
stack.append((level, node_id))
else:
while stack and stack[-1][0] >= level:
stack.pop()
if stack:
edges.append(f"{stack[-1][1]} --> {node_id}")
stack.append((level, node_id))
else:
stack.append((level, node_id))
return "%%{init: {'themeVariables': {'fontSize': '18px'}}}%%\nflowchart LR\n" + "\n".join(nodes + edges + clicks)
def generate_mermaid_html(mermaid_code):
"""Generate HTML to display Mermaid diagram."""
return f"""
<html><head><script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
<style>.centered-mermaid{{display:flex;justify-content:center;margin:20px auto;}}</style></head>
<body><div class="mermaid centered-mermaid">{mermaid_code}</div>
<script>mermaid.initialize({{startOnLoad:true}});</script></body></html>
"""
def grow_tree(base_tree, new_node_name, parent_node):
"""Add a new node to the tree under a specified parent."""
lines = base_tree.strip().split('\n')
new_lines = []
added = False
for line in lines:
new_lines.append(line)
if parent_node in line and not added:
indent = len(line) - len(line.lstrip())
new_lines.append(f"{' ' * (indent + 4)}- {new_node_name} ๐ฑ")
added = True
return "\n".join(new_lines)
def get_download_link(file_path, mime_type="text/plain"):
"""Generate a download link for a file."""
with open(file_path, 'rb') as f:
data = f.read()
b64 = base64.b64encode(data).decode()
return f'<a href="data:{mime_type};base64,{b64}" download="{file_path}">Download {file_path}</a>'
def save_tree_to_file(tree_text, parent_node, new_node):
"""Save tree to a markdown file with name based on nodes."""
root_node = tree_text.strip().split('\n')[0].split('.')[1].strip() if tree_text.strip() else "Knowledge_Tree"
filename = f"{sanitize_filename(root_node)}_{sanitize_filename(parent_node)}_{sanitize_filename(new_node)}_{int(time.time())}.md"
mermaid_code = parse_outline_to_mermaid(tree_text, "๐ฎGoogle") # Default search engine for saved trees
export_md = f"# Knowledge Tree: {root_node}\n\n## Outline\n{tree_text}\n\n## Mermaid Diagram\n```mermaid\n{mermaid_code}\n```"
with open(filename, "w") as f:
f.write(export_md)
return filename
def load_trees_from_files():
"""Load all saved tree markdown files."""
tree_files = glob.glob("*.md")
trees_dict = {}
for file in tree_files:
if file != "README.md" and file != "knowledge_tree.md": # Skip project README and temp export
try:
with open(file, 'r') as f:
content = f.read()
# Extract the tree name from the first line
match = re.search(r'# Knowledge Tree: (.*)', content)
if match:
tree_name = match.group(1)
else:
tree_name = os.path.splitext(file)[0]
# Extract the outline section
outline_match = re.search(r'## Outline\n(.*?)(?=\n## |$)', content, re.DOTALL)
if outline_match:
tree_outline = outline_match.group(1).strip()
trees_dict[f"{tree_name} ({file})"] = tree_outline
except Exception as e:
print(f"Error loading {file}: {e}")
return trees_dict
# Search Agents (Highest resolution social network default: X)
search_urls = {
"๐๐ArXiv": lambda k: f"/?q={quote(k)}",
"๐ฎGoogle": lambda k: f"https://www.google.com/search?q={quote(k)}",
"๐บYoutube": lambda k: f"https://www.youtube.com/results?search_query={quote(k)}",
"๐ญBing": lambda k: f"https://www.bing.com/search?q={quote(k)}",
"๐กTruth": lambda k: f"https://truthsocial.com/search?q={quote(k)}",
"๐ฑX": lambda k: f"https://twitter.com/search?q={quote(k)}",
}
# Main App
st.title("๐ณ AI Knowledge Tree Builder ๐ฑ")
# Sidebar with saved trees
st.sidebar.title("Saved Trees")
saved_trees = load_trees_from_files()
selected_saved_tree = st.sidebar.selectbox("Select a saved tree", ["None"] + list(saved_trees.keys()))
# Select Project Type
project_type = st.selectbox("Select Project Type", ["Code Project", "Papers Project", "AI Project"])
# Initialize or load tree
if 'current_tree' not in st.session_state:
if selected_saved_tree != "None" and selected_saved_tree in saved_trees:
st.session_state['current_tree'] = saved_trees[selected_saved_tree]
else:
st.session_state['current_tree'] = trees.get("ML Engineering", project_seeds[project_type])
elif selected_saved_tree != "None" and selected_saved_tree in saved_trees:
st.session_state['current_tree'] = saved_trees[selected_saved_tree]
# Select Search Agent for Node Links
search_agent = st.selectbox("Select Search Agent for Node Links", list(search_urls.keys()), index=5) # Default to X
# Tree Growth
new_node = st.text_input("Add New Node")
parent_node = st.text_input("Parent Node")
if st.button("Grow Tree ๐ฑ") and new_node and parent_node:
st.session_state['current_tree'] = grow_tree(st.session_state['current_tree'], new_node, parent_node)
# Save to a new file with the node names
saved_file = save_tree_to_file(st.session_state['current_tree'], parent_node, new_node)
st.success(f"Added '{new_node}' under '{parent_node}' and saved to {saved_file}!")
# Also update the temporary current_tree.md for compatibility
with open("current_tree.md", "w") as f:
f.write(st.session_state['current_tree'])
# Display Mermaid Diagram
st.markdown("### Knowledge Tree Visualization")
mermaid_code = parse_outline_to_mermaid(st.session_state['current_tree'], search_agent)
components.html(generate_mermaid_html(mermaid_code), height=600)
# Export Tree
if st.button("Export Tree as Markdown"):
export_md = f"# Knowledge Tree\n\n## Outline\n{st.session_state['current_tree']}\n\n## Mermaid Diagram\n```mermaid\n{mermaid_code}\n```"
with open("knowledge_tree.md", "w") as f:
f.write(export_md)
st.markdown(get_download_link("knowledge_tree.md", "text/markdown"), unsafe_allow_html=True)
# AI Project: Minimal ML Model Building
if project_type == "AI Project":
st.subheader("Build Minimal ML Model from CSV")
uploaded_file = st.file_uploader("Upload CSV", type="csv")
if uploaded_file:
df = pd.read_csv(uploaded_file)
st.write("Columns:", df.columns.tolist())
feature_cols = st.multiselect("Select feature columns", df.columns)
target_col = st.selectbox("Select target column", df.columns)
if st.button("Train Model"):
X = df[feature_cols].values
y = df[target_col].values
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)
dataset = TensorDataset(X_tensor, y_tensor)
loader = DataLoader(dataset, batch_size=32, shuffle=True)
model = nn.Linear(X.shape[1], 1)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
for epoch in range(10):
for batch_X, batch_y in loader:
optimizer.zero_grad()
outputs = model(batch_X)
loss = criterion(outputs, batch_y)
loss.backward()
optimizer.step()
torch.save(model.state_dict(), "model.pth")
app_code = f"""
import streamlit as st
import torch
import torch.nn as nn
model = nn.Linear({len(feature_cols)}, 1)
model.load_state_dict(torch.load("model.pth"))
model.eval()
st.title("ML Model Demo")
inputs = []
for col in {feature_cols}:
inputs.append(st.number_input(col))
if st.button("Predict"):
input_tensor = torch.tensor([inputs], dtype=torch.float32)
prediction = model(input_tensor).item()
st.write(f"Predicted {target_col}: {{prediction}}")
"""
with open("app.py", "w") as f:
f.write(app_code)
reqs = "streamlit\ntorch\npandas\n"
with open("requirements.txt", "w") as f:
f.write(reqs)
readme = """
# ML Model Demo
## How to run
1. Install requirements: `pip install -r requirements.txt`
2. Run the app: `streamlit run app.py`
3. Input feature values and click "Predict".
"""
with open("README.md", "w") as f:
f.write(readme)
st.markdown(get_download_link("model.pth", "application/octet-stream"), unsafe_allow_html=True)
st.markdown(get_download_link("app.py", "text/plain"), unsafe_allow_html=True)
st.markdown(get_download_link("requirements.txt", "text/plain"), unsafe_allow_html=True)
st.markdown(get_download_link("README.md", "text/markdown"), unsafe_allow_html=True)