Update app.py

app.py

@@ -27,17 +27,18 @@ def main():
         ["RAG comparison demonstration", "Knowledge graph visualization", "Ontology structure analysis", "Entity exploration", "Semantic path visualization", "Inference tracking", "Detailed comparative analysis"]
     )
     
-    if page == "RAG Comparison Demo":
+    # 修正條件判斷，使其與選項名稱一致
+    if page == "RAG comparison demonstration":
         run_rag_demo()
-    elif page == "Knowledge Graph Visualization":
+    elif page == "Knowledge graph visualization":
         run_knowledge_graph_visualization()
-    elif page == "Ontology Structure Analysis":
+    elif page == "Ontology structure analysis":
         run_ontology_structure_analysis()
-    elif page == "Entity Exploration":
+    elif page == "Entity exploration":
         run_entity_exploration()
-    elif page == "Semantic Path Visualization":
+    elif page == "Semantic path visualization":
         run_semantic_path_visualization()
-    elif page == "Inference Tracking":
+    elif page == "Inference tracking":
         run_reasoning_trace()
     elif page == "Detailed comparative analysis":
         run_detailed_comparison()
@@ -69,15 +70,15 @@ def run_rag_demo():
                 )
                 vector_answer = vector_response.choices[0].message.content
 
-                st.markdown("#### answer")
+                st.markdown("#### Answer")
                 st.write(vector_answer)
 
-                st.markdown("#### retrieval context")
+                st.markdown("#### Retrieved Context")
                 for i, doc in enumerate(vector_docs):
                     with st.expander(f"Source {i+1}"):
                         st.code(doc.page_content)
 
-            # # Ontology RAG
+            # Ontology RAG
             with col2:
                 st.subheader("Ontology RAG")
                 result = semantic_retriever.retrieve_with_paths(query, k=k_val)
@@ -93,18 +94,18 @@ def run_rag_demo():
                 )
                 enhanced_answer = enhanced_response.choices[0].message.content
 
-                st.markdown("#### answer")
+                st.markdown("#### Answer")
                 st.write(enhanced_answer)
 
-                st.markdown("#### Search context")
+                st.markdown("#### Retrieved Context")
                 for i, doc in enumerate(retrieved_docs):
                     source = doc.metadata.get("source", "unknown")
                     label = {
-                        "ontology": "Ontology context",
-                        "text": "Text context",
-                        "ontology_context": "Semantic context",
-                        "semantic_path": "Relationship path"
-                    }.get(source, f"source")
+                        "ontology": "Ontology Context",
+                        "text": "Text Context",
+                        "ontology_context": "Semantic Context",
+                        "semantic_path": "Relationship Path"
+                    }.get(source, f"Source")
                     with st.expander(f"{label} {i+1}"):
                         st.markdown(doc.page_content)
                 
@@ -120,38 +121,38 @@ def run_rag_demo():
         st.markdown("""
         The above comparison demonstrates several key advantages of ontology-enhanced RAG:
         
-        1. **Structure-aware**: Ontology-augmented methods understand the relationships between entities, not just their textual similarities.
+        1. **Structural Awareness**: The ontology-enhanced approach understands the relationships between entities, not just their textual similarity.
         
-        2. **Multi-hop reasoning**: By using the knowledge graph structure, the enhancement method can connect information across multiple relational jumps.
+        2. **Multi-hop Reasoning**: By using the knowledge graph structure, the enhanced approach can connect information across multiple relationship hops.
         
-        3. **Context enrichment**: Ontologies provide additional context about entity types, attributes, and relationships that are not explicit in the text.
+        3. **Context Enrichment**: The ontology provides additional context about entity types, properties, and relationships that isn't explicit in the text.
         
-        4. Reasoning ability: Structured knowledge allows for logical reasoning that vector similarity alone cannot achieve.
+        4. **Inference Capabilities**: The structured knowledge allows for logical inferences that vector similarity alone cannot achieve.
         
-        Try more complex queries that require understanding of relationships to see the differences more clearly!
+        Try more complex queries that require understanding relationships to see the differences more clearly!
         """)
 
 def run_knowledge_graph_visualization():
     st.title("Knowledge Graph Visualization")
     
-    # Check if there is a center entity selected
+    # Check if there is a central entity selected
     central_entity = st.session_state.get('central_entity', None)
     
-    # Check if there is a center entity selected
+    # Call visualization function
     display_graph_visualization(knowledge_graph, central_entity=central_entity, max_distance=2)
     
-    # Get and display graphical statistics
+    # Get and display graph statistics
     graph_stats = knowledge_graph.get_graph_statistics()
     if graph_stats:
-        st.subheader("Graphical Statistics")
+        st.subheader("Graph Statistics")
         
         col1, col2, col3, col4 = st.columns(4)
-        col1.metric("Total number of nodes", graph_stats.get("node_count", 0))
-        col2.metric("Total number of edges", graph_stats.get("edge_count", 0))
-        col3.metric("total number of classes", graph_stats.get("class_count", 0))
-        col4.metric("Total number of instances", graph_stats.get("instance_count", 0))
+        col1.metric("Nodes", graph_stats.get("node_count", 0))
+        col2.metric("Edges", graph_stats.get("edge_count", 0))
+        col3.metric("Classes", graph_stats.get("class_count", 0))
+        col4.metric("Instances", graph_stats.get("instance_count", 0))
         
-        # Display the central node
+        # Display central nodes
         if "central_nodes" in graph_stats and graph_stats["central_nodes"]:
             st.subheader("Central Nodes (by Betweenness Centrality)")
             central_nodes = graph_stats["central_nodes"]["betweenness"]
@@ -167,7 +168,7 @@ def run_knowledge_graph_visualization():
                     nodes_df.append({
                         "ID": node_id,
                         "Name": name,
-                        "type": node_class,
+                        "Type": node_class,
                         "Centrality": node_info["centrality"]
                     })
             
@@ -176,11 +177,11 @@ def run_knowledge_graph_visualization():
 def run_ontology_structure_analysis():
     st.title("Ontology Structure Analysis")
     
-    # Use the existing ontology statistics display function
+    # Use ontology statistics display function
     display_ontology_stats(ontology_manager)
     
-    # Add additional class hierarchy visualization
-    st.subheader("class hierarchy")
+    # Add class hierarchy visualization
+    st.subheader("Class Hierarchy")
     
     # Get class hierarchy data
     class_hierarchy = ontology_manager.get_class_hierarchy()
@@ -196,19 +197,41 @@ def run_ontology_structure_analysis():
             G.add_node(child)
             G.add_edge(parent, child)
     
-    # Check if there are enough nodes to create the visualization
+    # Check if there are enough nodes to create visualization
     if len(G.nodes) > 1:
         # Generate HTML visualization using knowledge graph class
         kg = KnowledgeGraph(ontology_manager)
+        
+        # Use built-in layout algorithm
         html = kg.generate_html_visualization(
             include_classes=True,
             include_instances=False,
             max_distance=5,
-            layout_algorithm="hierarchical"
+            layout_algorithm="hierarchical"  # Use the built-in hierarchical layout
         )
         
-        # Rendering HTML
+        # Render HTML
         render_html_in_streamlit(html)
+        
+        # Add extra tree view for each root node
+        with st.expander("Node Tree View", expanded=False):
+            # Find root nodes (nodes without parent nodes)
+            roots = [n for n in G.nodes() if G.in_degree(n) == 0]
+            
+            # Display tree structure for each root node
+            for root in roots:
+                st.markdown(f"### Root Node: {root}")
+                
+                # Recursively display child nodes
+                def display_tree(node, depth=0):
+                    children = list(G.successors(node))
+                    if children:
+                        for child in sorted(children):
+                            st.markdown(" " * depth * 4 + f"- {child}")
+                            display_tree(child, depth + 1)
+                
+                display_tree(root)
+                st.markdown("---")
 
 def run_entity_exploration():
     st.title("Entity Exploration")
@@ -221,8 +244,8 @@ def run_entity_exploration():
     # Remove duplicates and sort
     entities = sorted(set(entities))
     
-    # Create a drop-down selection box
-    selected_entity = st.selectbox("Select entity", entities)
+    # Create a dropdown selection box
+    selected_entity = st.selectbox("Select Entity", entities)
     
     if selected_entity:
         # Get entity information
@@ -232,13 +255,13 @@ def run_entity_exploration():
         display_entity_details(entity_info, ontology_manager)
         
         # Set this entity as the central entity (for knowledge graph visualization)
-        if st.button("View this entity in the knowledge graph"):
+        if st.button("View this Entity in the Knowledge Graph"):
             st.session_state.central_entity = selected_entity
             st.rerun()
         
         # Get and display entity neighbors
         st.subheader("Entity Neighborhood")
-        max_distance = st.slider("Maximum neighborhood distance", 1, 3, 1)
+        max_distance = st.slider("Maximum Neighborhood Distance", 1, 3, 1)
         
         neighborhood = knowledge_graph.get_entity_neighborhood(
             selected_entity, 
@@ -252,7 +275,7 @@ def run_entity_exploration():
                 neighbors_at_distance = [n for n in neighborhood["neighbors"] if n["distance"] == distance]
                 
                 if neighbors_at_distance:
-                    with st.expander(f"Neighbors at distance {distance} ({len(neighbors_at_distance)})"):
+                    with st.expander(f"Neighbors at Distance {distance} ({len(neighbors_at_distance)})"):
                         for neighbor in neighbors_at_distance:
                             st.markdown(f"**{neighbor['id']}** ({neighbor.get('class_type', 'unknown')})")
                             
@@ -278,16 +301,16 @@ def run_semantic_path_visualization():
     col1, col2 = st.columns(2)
     
     with col1:
-        source_entity = st.selectbox("Select source entity", entities, key="source")
+        source_entity = st.selectbox("Select Source Entity", entities, key="source")
     
     with col2:
-        target_entity = st.selectbox("Select target entity", entities, key="target")
+        target_entity = st.selectbox("Select Target Entity", entities, key="target")
     
     if source_entity and target_entity and source_entity != target_entity:
         # Provide a maximum path length option
-        max_length = st.slider("Maximum path length", 1, 5, 3)
+        max_length = st.slider("Maximum Path Length", 1, 5, 3)
         
-        # Find the path
+        # Find paths
         paths = knowledge_graph.find_paths_between_entities(
             source_entity, 
             target_entity,
@@ -295,15 +318,15 @@ def run_semantic_path_visualization():
         )
         
         if paths:
-            st.success(f"Found {len(paths)} paths！")
+            st.success(f"Found {len(paths)} paths!")
             
             # Create expanders for each path
             for i, path in enumerate(paths):
-                # Calculate path length and relationship type
+                # Calculate path length and relationship types
                 path_length = len(path)
                 rel_types = [edge["type"] for edge in path]
                 
-                with st.expander(f"path {i+1} (length: {path_length}, relation: {', '.join(rel_types)})", expanded=(i==0)):
+                with st.expander(f"Path {i+1} (Length: {path_length}, Relations: {', '.join(rel_types)})", expanded=(i==0)):
                     # Create a text description of the path
                     path_text = []
                     entities_in_path = []
@@ -316,7 +339,7 @@ def run_semantic_path_visualization():
                         entities_in_path.append(source)
                         entities_in_path.append(target)
                         
-                        # Get entity information to get a human-readable name
+                        # Get entity information to get a readable name
                         source_info = ontology_manager.get_entity_info(source)
                         target_info = ontology_manager.get_entity_info(target)
                         
@@ -344,13 +367,13 @@ def run_semantic_path_visualization():
                     # Display path visualization
                     visualize_path(path_info, ontology_manager)
         else:
-            st.warning(f"No path of length {max_length} or shorter was found between these entities.")
+            st.warning(f"No paths of length {max_length} or shorter were found between these entities.")
 
 def run_reasoning_trace():
-    st.title("Inference Tracking Visualization")
+    st.title("Reasoning Trace Visualization")
     
     if not st.session_state.get("query") or not st.session_state.get("retrieved_docs") or not st.session_state.get("answer"):
-        st.warning("Please run a query on the RAG comparison page first to generate inference trace data.")
+        st.warning("Please run a query on the RAG comparison page first to generate reasoning trace data.")
         return
     
     # Get data from session state
@@ -358,11 +381,11 @@ def run_reasoning_trace():
     retrieved_docs = st.session_state.retrieved_docs
     answer = st.session_state.answer
     
-    # Show inference trace
+    # Show reasoning trace
     display_reasoning_trace(query, retrieved_docs, answer, ontology_manager)
 
 def run_detailed_comparison():
-    st.title("Detailed comparison of RAG methods")
+    st.title("Detailed Comparison of RAG Methods")
     
     # Add comparison query options
     comparison_queries = [
@@ -374,7 +397,7 @@ def run_detailed_comparison():
     ]
     
     selected_query = st.selectbox(
-        "Select Compare Query", 
+        "Select Comparison Query", 
         comparison_queries,
         index=0
     )
@@ -386,8 +409,8 @@ def run_detailed_comparison():
     else:
         query = selected_query
     
-    if st.button("Compare RAG methods"):
-        with st.spinner("Run detailed comparison..."):
+    if st.button("Compare RAG Methods"):
+        with st.spinner("Running detailed comparison..."):
             # Start timing
             import time
             start_time = time.time()
@@ -406,10 +429,10 @@ def run_detailed_comparison():
             vector_answer = vector_response.choices[0].message.content
             vector_time = time.time() - start_time
             
-            # Reset the timer
+            # Reset timer
             start_time = time.time()
             
-            # Run the enhanced RAG
+            # Run ontology-enhanced RAG
             result = semantic_retriever.retrieve_with_paths(query, k=k_val)
             retrieved_docs = result["documents"]
             enhanced_context = "\n\n".join([doc.page_content for doc in retrieved_docs])
@@ -424,59 +447,59 @@ def run_detailed_comparison():
             enhanced_answer = enhanced_response.choices[0].message.content
             enhanced_time = time.time() - start_time
             
-            # Save the results for visualization
+            # Save results for visualization
             st.session_state.query = query
             st.session_state.retrieved_docs = retrieved_docs
             st.session_state.answer = enhanced_answer
             
-            # Display the comparison results
-            st.subheader("Comparison results")
+            # Display comparison results
+            st.subheader("Comparison Results")
             
-            # Use tabs to show comparisons in different aspects
-            tab1, tab2, tab3, tab4 = st.tabs(["Answer Comparison", "Performance Indicators", "Retrieval Source Comparison", "Context Quality"])
+            # Use tabs to show different aspects of comparison
+            tab1, tab2, tab3, tab4 = st.tabs(["Answer Comparison", "Performance Metrics", "Retrieval Source Comparison", "Context Quality"])
             
             with tab1:
                 col1, col2 = st.columns(2)
                 
                 with col1:
-                    st.markdown("#### Traditional RAG answer")
+                    st.markdown("#### Traditional RAG Answer")
                     st.write(vector_answer)
                 
                 with col2:
-                    st.markdown("#### Ontology Enhanced RAG Answer")
+                    st.markdown("#### Ontology-Enhanced RAG Answer")
                     st.write(enhanced_answer)
             
             with tab2:
-                # Performance Indicators
+                # Performance metrics
                 col1, col2 = st.columns(2)
                 
                 with col1:
-                    st.metric("Traditional RAG response time", f"{vector_time:.2f}秒")
+                    st.metric("Traditional RAG Response Time", f"{vector_time:.2f} seconds")
                     
-                    # Calculate text related indicators
+                    # Calculate text metrics
                     vector_tokens = len(vector_context.split())
-                    st.metric("Number of retrieved context tokens", vector_tokens)
+                    st.metric("Retrieved Context Tokens", vector_tokens)
                     
-                    st.metric("Number of retrieved documents", len(vector_docs))
+                    st.metric("Retrieved Documents", len(vector_docs))
                 
                 with col2:
-                    st.metric("Ontology enhanced RAG response time", f"{enhanced_time:.2f}秒")
+                    st.metric("Ontology-Enhanced RAG Response Time", f"{enhanced_time:.2f} seconds")
                     
-                    # Calculate text related indicators
+                    # Calculate text metrics
                     enhanced_tokens = len(enhanced_context.split())
-                    st.metric("Number of retrieved context tokens", enhanced_tokens)
+                    st.metric("Retrieved Context Tokens", enhanced_tokens)
                     
-                    st.metric("Number of retrieved documents", len(retrieved_docs))
+                    st.metric("Retrieved Documents", len(retrieved_docs))
                 
-                # Add a chart
+                # Add chart
                 import pandas as pd
                 import plotly.express as px
                 
                 # Performance comparison chart
                 performance_data = {
-                    "Metrics": ["Response time (seconds)", "Number of context tags", "Number of retrieved documents"],
+                    "Metrics": ["Response Time (seconds)", "Context Tokens", "Retrieved Documents"],
                     "Traditional RAG": [vector_time, vector_tokens, len(vector_docs)],
-                    "Ontology Enhanced RAG": [enhanced_time, enhanced_tokens, len(retrieved_docs)]
+                    "Ontology-Enhanced RAG": [enhanced_time, enhanced_tokens, len(retrieved_docs)]
                 }
                 
                 df = pd.DataFrame(performance_data)
@@ -484,31 +507,31 @@ def run_detailed_comparison():
                 # Plotly bar chart
                 fig = px.bar(
                     df, 
-                    x="Indicator", 
-                    y=["Traditional RAG", "Ontology Enhanced RAG"],
+                    x="Metrics",  # Fixed column name
+                    y=["Traditional RAG", "Ontology-Enhanced RAG"],
                     barmode="group",
-                    title="Performance Index Comparison",
-                    labels={"value": "Numerical value", "variable": "RAG method"}
+                    title="Performance Metrics Comparison",
+                    labels={"value": "Value", "variable": "RAG Method"}
                 )
                 
-                st.plotly_chart(fig)
+                st.plotly_chart(fig, use_container_width=True)
             
             with tab3:
-                # Search source comparison
-                traditional_sources = ["Traditional vector retrieval"] * len(vector_docs)
+                # Retrieval source comparison
+                traditional_sources = ["Traditional Vector Retrieval"] * len(vector_docs)
                 
                 enhanced_sources = []
                 for doc in retrieved_docs:
                     source = doc.metadata.get("source", "unknown")
                     label = {
-                        "ontology": "Ontology context",
-                        "text": "Text context",
-                        "ontology_context": "Semantic context",
-                        "semantic_path": "Relationship path"
-                    }.get(source, "unknown source")
+                        "ontology": "Ontology Context",
+                        "text": "Text Context",
+                        "ontology_context": "Semantic Context",
+                        "semantic_path": "Relationship Path"
+                    }.get(source, "Unknown Source")
                     enhanced_sources.append(label)
                 
-                # Create a source distribution chart
+                # Create source distribution chart
                 source_counts = {}
                 for source in enhanced_sources:
                     if source in source_counts:
@@ -517,32 +540,32 @@ def run_detailed_comparison():
                         source_counts[source] = 1
                 
                 source_df = pd.DataFrame({
-                    "Source type": list(source_counts.keys()),
-                    "Number of documents": list(source_counts.values())
+                    "Source Type": list(source_counts.keys()),
+                    "Document Count": list(source_counts.values())
                 })
                 
                 fig = px.pie(
                     source_df,
-                    values="Number of documents",
-                    names="Source type",
-                    title="Ontology-enhanced RAG retrieval source distribution"
+                    values="Document Count",
+                    names="Source Type",
+                    title="Ontology-Enhanced RAG Retrieval Source Distribution"
                 )
                 
-                st.plotly_chart(fig)
+                st.plotly_chart(fig, use_container_width=True)
                 
-                # Show the relationship between the source and the answer
-                st.subheader("Relationship between source and answer")
+                # Show source-answer relationship
+                st.subheader("Relationship Between Sources and Answer")
                 st.markdown("""
                 Ontology-enhanced methods leverage multiple sources of knowledge to construct more comprehensive answers. The figure above shows the distribution of different sources.
                 
-                In particular, semantic context and relation paths provide knowledge that cannot be captured by traditional vector retrieval, enabling the system to connect concepts and perform multi-hop reasoning.
+                In particular, semantic context and relationship paths provide knowledge that cannot be captured by traditional vector retrieval, enabling the system to connect concepts and perform multi-hop reasoning.
                 """)
             
             with tab4:
-                # Contextual quality assessment
-                st.subheader("Contextual Quality Assessment")
+                # Context quality assessment
+                st.subheader("Context Quality Assessment")
                 
-                # Create an evaluation function (simplified version)
+                # Create evaluation function (simplified)
                 def evaluate_context(docs):
                     metrics = {
                         "Direct Relevance": 0,
@@ -556,18 +579,18 @@ def run_detailed_comparison():
                         
                         # Direct Relevance - Based on Keywords
                         if any(kw in content.lower() for kw in query.lower().split()):
-                            metrics["direct relevance"] += 1
+                            metrics["Direct Relevance"] += 1  # Fixed key name
                         
                         # Semantic richness - based on text length
-                        metrics["semantic richness"] += min(1, len(content.split()) / 50)
+                        metrics["Semantic Richness"] += min(1, len(content.split()) / 50)  # Fixed key name
                         
-                        # Structural information - from the body
+                        # Structural information - from ontology
                         if hasattr(doc, "metadata") and doc.metadata.get("source") in ["ontology", "ontology_context"]:
                             metrics["Structure Information"] += 1
                         
                         # Relationship information - from path
                         if hasattr(doc, "metadata") and doc.metadata.get("source") == "semantic_path":
-                            metrics["relationship information"] += 1
+                            metrics["Relationship Information"] += 1  # Fixed key name
                     
                     # Standardization
                     for key in metrics:
@@ -575,109 +598,113 @@ def run_detailed_comparison():
                     
                     return metrics
                 
-                # Evaluate the two methods
+                # Evaluate both methods
                 vector_metrics = evaluate_context(vector_docs)
                 enhanced_metrics = evaluate_context(retrieved_docs)
                 
-                # Create a comparative radar chart
+                # Create comparative radar chart
                 metrics_df = pd.DataFrame({
                     "metrics": list(vector_metrics.keys()),
                     "Traditional RAG": list(vector_metrics.values()),
-                    "Ontology Enhanced RAG": list(enhanced_metrics.values())
+                    "Ontology-Enhanced RAG": list(enhanced_metrics.values())
                 })
                 
                 # Convert data to Plotly radar chart format
                 fig = px.line_polar(
                     metrics_df, 
-                    r=["Traditional RAG", "Ontology Enhanced RAG"], 
-                    theta="Indicator", 
+                    r=["Traditional RAG", "Ontology-Enhanced RAG"], 
+                    theta="metrics",  # Fixed column name
                     line_close=True,
                     range_r=[0, 10],
-                    title="Contextual Quality Comparison"
+                    title="Context Quality Comparison"
                 )
                 
-                st.plotly_chart(fig)
+                st.plotly_chart(fig, use_container_width=True)
                 
                 st.markdown("""
-                The figure above shows the comparison of the two RAG methods in terms of contextual quality. Ontology-enhanced RAG performs better in multiple dimensions:
+                                The figure above shows a comparison of the two RAG methods in terms of context quality. Ontology-enhanced RAG performs better in multiple dimensions:
+                                
+                                1. **Direct Relevance**: The degree of relevance between the retrieved content and the query
+                                2. **Semantic Richness**: Information density and richness of the retrieval context
+                                3. **Structural Information**: Structured knowledge of entity types, attributes, and relationships
+                                4. **Relationship Information**: Explicit relationships and connection paths between entities
+                                
+                                The advantage of ontology-enhanced RAG is that it can retrieve structured knowledge and relational information, which are missing in traditional RAG methods.
+                                """)
+                        
+            # Display detailed analysis section
+            st.subheader("Method Effectiveness Analysis")
+            
+            with st.expander("Comparison of Advantages and Disadvantages", expanded=True):
+                col1, col2 = st.columns(2)
                 
-                1. **Direct relevance**: the degree of relevance between the search content and the query
-                2. **Semantic Richness**: Information density and richness of the retrieval context
-                3. **Structural information**: structured knowledge of entity types, attributes, and relationships
-                4. **Relationship information**: explicit relationships and connection paths between entities
+                with col1:
+                    st.markdown("#### Traditional RAG")
+                    st.markdown("""
+                    **Advantages**:
+                    - Simple implementation and light computational burden
+                    - Works well with unstructured text
+                    - Response times are usually faster
+                    
+                    **Disadvantages**:
+                    - Unable to capture relationships between entities
+                    - Lack of context for structured knowledge
+                    - Difficult to perform multi-hop reasoning
+                    - Retrieval is mainly based on text similarity
+                    """)
                 
-                The advantage of ontology-enhanced RAG is that it can retrieve structured knowledge and relational information, which are missing in traditional RAG methods.
-                """)
-        
-        # Display detailed analysis section
-        st.subheader("Method Effect Analysis")
-        
-        with st.expander("Comparison of advantages and disadvantages", expanded=True):
-            col1, col2 = st.columns(2)
+                with col2:
+                    st.markdown("#### Ontology Enhanced RAG")
+                    st.markdown("""
+                    **Advantages**:
+                    - Ability to understand relationships and connections between entities
+                    - Provides rich structured knowledge context
+                    - Support multi-hop reasoning and path discovery
+                    - Combining vector similarity and semantic relationship
+                    
+                    **Disadvantages**:
+                    - Higher implementation complexity
+                    - Need to maintain the ontology model
+                    - The computational overhead is relatively high
+                    - Retrieval and inference times may be longer
+                    """)
             
-            with col1:
-                st.markdown("#### Traditional RAG")
+            # Add usage scenario suggestions
+            with st.expander("Applicable Scenarios"):
                 st.markdown("""
-                **Advantages**:
-                - Simple implementation and light computational burden
-                - Works well with unstructured text
-                - Response times are usually faster
-                
-                **Disadvantages**:
-                - Unable to capture relationships between entities
-                - Lack of context for structured knowledge
-                - Difficult to perform multi-hop reasoning
-                - Retrieval is mainly based on text similarity
+                ### Traditional RAG Applicable Scenarios
+                
+                - Simple fact-finding
+                - Unstructured document retrieval
+                - Applications with high response time requirements
+                - When the document content is clear and direct
+                
+                ### Applicable Scenarios for Ontology Enhanced RAG
+                
+                - Complex knowledge association query
+                - Problems that require understanding of relationships between entities
+                - Applications that require cross-domain reasoning
+                - Enterprise Knowledge Management System
+                - Reasoning scenarios that require high accuracy and consistency
+                - Applications that require implicit knowledge discovery
                 """)
-            
-            with col2:
-                st.markdown("#### Ontology Enhanced RAG")
+
+            # Add practical application examples
+            with st.expander("Application Case Studies"):
                 st.markdown("""
-                **Advantages**:
-                - Ability to understand relationships and connections between entities
-                - Provides rich structured knowledge context
-                - Support multi-hop reasoning and path discovery
-                - Combining vector similarity and semantic relationship
-                
-                **Disadvantages**:
-                - Higher implementation complexity
-                - Need to maintain the ontology model
-                - The computational overhead is relatively high
-                - Retrieval and inference times may be longer
+                ### Enterprise Knowledge Management
+                Ontology-enhanced RAG systems can help enterprises effectively organize and access their knowledge assets, connect information in different departments and systems, and provide more comprehensive business insights.
+                
+                ### Product Development Decision Support
+                By understanding the relationship between customer feedback, product features, and market data, the system can provide more valuable support for product development decisions.
+                
+                ### Complex Compliance Queries
+                In compliance problems that require consideration of multiple rules and relationships, ontology-enhanced RAG can provide rule-based reasoning, ensuring that recommendations comply with all applicable policies and regulations.
+                
+                ### Diagnostics and Troubleshooting
+                In technical support and troubleshooting scenarios, the system can connect symptoms, causes, and solutions to provide more accurate diagnoses through multi-hop reasoning.
                 """)
-        
-        # Add usage scenario suggestions
-        with st.expander("Applicable scenarios"):
-            st.markdown("""
-            ### Traditional RAG applicable scenarios
-            
-            - Simple fact-finding
-            - Unstructured document retrieval
-            - Applications with high response time requirements
-            - When the document content is clear and direct
-            
-            ### Applicable scenarios for Ontology Enhanced RAG
-            
-            - Complex knowledge association query
-            - Problems that require understanding of relationships between entities
-            - Applications that require cross-domain reasoning
-            - Enterprise Knowledge Management System
-            - Reasoning scenarios that require high accuracy and consistency
-            - Applications that require implicit knowledge discovery
-            """)
 
-        # Add practical application examples
-        with st.expander("Actual Application Case"):
-            st.markdown("""
-            ### Enterprise Knowledge Management
-            Ontology-enhanced RAG systems can help enterprises effectively organize and access their knowledge assets, connect information in different departments and systems, and provide more comprehensive business insights.
-            
-            ### Product development decision support
-            By understanding the relationship between customer feedback, product features, and market data, the system can provide more valuable support for product development decisions.
-            
-            ### Complex compliance query
-            In compliance problems that require consideration of multiple rules and relationships, ontology-enhanced RAG can provide rule-based reasoning, ensuring that recommendations comply with all applicable policies and regulations.
-            
-            ### Diagnostics and Troubleshooting
-            In technical support and troubleshooting scenarios, the system can connect symptoms, causes, and solutions to provide more accurate diagnoses through multi-hop reasoning.
-            """)
+if __name__ == "__main__":
+    main()
+