|
import streamlit as st |
|
import google.generativeai as genai |
|
import json |
|
import time |
|
from streamlit.components.v1 import html |
|
|
|
|
|
api_key = "AIzaSyBbusXSbq7JTI8Sa7vjGqu-h2zluKhDpX8" |
|
genai.configure(api_key=api_key) |
|
|
|
|
|
model = genai.GenerativeModel( |
|
model_name="gemini-1.5-pro-latest", |
|
generation_config=genai.GenerationConfig( |
|
temperature=0.2, |
|
max_output_tokens=2048 |
|
) |
|
) |
|
|
|
|
|
st.set_page_config(page_title="Lecture Notes Mindmap Generator", layout="wide") |
|
st.title("Lecture Notes Mindmap Generator") |
|
|
|
|
|
if "lecture_notes" not in st.session_state: |
|
st.session_state.lecture_notes = "" |
|
if "current_mindmap" not in st.session_state: |
|
st.session_state.current_mindmap = None |
|
if "processed_chunks" not in st.session_state: |
|
st.session_state.processed_chunks = 0 |
|
|
|
|
|
lecture_notes = st.text_area("Paste your lecture notes here:", height=300, value=st.session_state.lecture_notes) |
|
|
|
|
|
def chunk_notes(notes, chunk_size=800): |
|
"""Breaks down lecture notes into smaller chunks for efficient processing.""" |
|
return [notes[i:i+chunk_size] for i in range(0, len(notes), chunk_size)] |
|
|
|
|
|
def generate_mindmap_step(notes_chunk, current_mindmap=None): |
|
prompt = f""" |
|
Create or extend a hierarchical mindmap structure based on the following lecture notes. |
|
The structure should be in JSON format, with each node having a 'name' and 'children' array. |
|
|
|
Current mindmap (if any): |
|
{json.dumps(current_mindmap) if current_mindmap else "{}"} |
|
|
|
New lecture notes chunk: |
|
{notes_chunk} |
|
|
|
Specific formatting instructions: |
|
1. Prioritize a clear, bulletin-style hierarchy (main topics, subtopics, supporting details). |
|
2. Use concise, informative names for each node to capture the essence of the concept. |
|
3. Ensure logical grouping: all children of a node should be directly related to its topic. |
|
4. Aim for 3-5 main topics to maintain a good overview and prevent overwhelming the user. |
|
5. Strive for consistency in depth and detail across similar levels of the mindmap. |
|
6. If a concept appears multiple times, find a way to consolidate or cross-reference it. |
|
7. **Important:** If you're unsure about the structure, err on the side of creating separate nodes for clarity. |
|
|
|
Return only the JSON structure of the entire updated mindmap, without any additional text or explanation. |
|
""" |
|
|
|
try: |
|
response = model.generate_content(prompt) |
|
response_text = response.text.strip() |
|
|
|
|
|
try: |
|
return json.loads(response_text) |
|
except json.JSONDecodeError as e: |
|
st.error(f"Error parsing JSON: {e}. Raw response: {response_text}") |
|
except Exception as e: |
|
st.error(f"An error occurred: {e}") |
|
|
|
|
|
def display_mindmap(data, indent=0): |
|
if isinstance(data, dict): |
|
if indent == 0: |
|
st.markdown(f"### {data['name']}") |
|
else: |
|
st.markdown(f"{' ' * indent}- {data['name']}") |
|
|
|
if 'children' in data and isinstance(data['children'], list): |
|
for child in data['children']: |
|
display_mindmap(child, indent + 1) |
|
|
|
|
|
if st.button("Generate/Continue Mindmap"): |
|
if lecture_notes: |
|
st.session_state.lecture_notes = lecture_notes |
|
chunks = chunk_notes(lecture_notes) |
|
|
|
with st.spinner("Generating mindmap... This may take a few minutes."): |
|
for i in range(st.session_state.processed_chunks, len(chunks)): |
|
st.text(f"Processing chunk {i+1} of {len(chunks)}...") |
|
|
|
step_mindmap = generate_mindmap_step(chunks[i], st.session_state.current_mindmap) |
|
|
|
if step_mindmap: |
|
st.session_state.current_mindmap = step_mindmap |
|
st.session_state.processed_chunks = i + 1 |
|
time.sleep(20) |
|
else: |
|
st.warning(f"Failed to process chunk {i+1}. You can try continuing from this point.") |
|
break |
|
|
|
if st.session_state.current_mindmap: |
|
st.success(f"Mindmap generated successfully! Processed {st.session_state.processed_chunks} out of {len(chunks)} chunks.") |
|
else: |
|
st.error("Failed to generate the mindmap. Please try again.") |
|
else: |
|
st.warning("Please enter your lecture notes first.") |
|
|
|
|
|
if st.button("Clear and Restart"): |
|
st.session_state.lecture_notes = "" |
|
st.session_state.current_mindmap = None |
|
st.session_state.processed_chunks = 0 |
|
st.success("Cleared all data. You can start a new mindmap generation.") |
|
|
|
|
|
if st.session_state.current_mindmap: |
|
st.subheader("Current Mindmap") |
|
display_mindmap(st.session_state.current_mindmap) |
|
|
|
|
|
if st.button("Download Mindmap as JSON"): |
|
json_string = json.dumps(st.session_state.current_mindmap, indent=2) |
|
st.download_button( |
|
label="Click here to download", |
|
file_name="mindmap.json", |
|
mime="application/json", |
|
data=json_string |
|
) |
|
|
|
st.write(""" |
|
To use this app: |
|
1. Paste your lecture notes into the text area. |
|
2. Click the "Generate/Continue Mindmap" button to start or continue the process. |
|
3. The mindmap will be generated in chunks, and you can see the progress. |
|
4. If the process is interrupted, you can continue from where it left off. |
|
5. Use the "Clear and Restart" button to start over with new notes. |
|
6. You can download the generated mindmap as a JSON file for future reference. |
|
""") |
|
|