graphrag

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 from rag import rbc_product
 from tool import rival_product
+from graphrag import reasoning
 
 with gr.Blocks() as demo:
   with gr.Tab("RAG"):
@@ -60,6 +61,63 @@ https://kevinwkc.github.io/davinci/
     btn_recommend=gr.Button("Recommend")
     btn_recommend.click(fn=rival_product, inputs=in_verbatim, outputs=out_product)
 
+  with gr.Tab("graphrag"):
+    gr.Markdown("""
+    Reasoning from context, answering the question
+    """)
+    in_verbatim = gr.Textbox(label="Context")
+    in_question = gr.Textbox(label="Question")
+    out_product = gr.Textbox(label="Answer")
+
+    gr.Examples(
+      [
+        [
+          """
+A business model is not merely a static description but a dynamic ecosystem defined by five interdependent pillars:
+
+Value Creation (What you sell): The core offering must solve a critical pain point or unlock untapped demand. This is the foundation of your value proposition—quantifiable (e.g., cost efficiency) or qualitative (e.g., exceptional user experience)—that differentiates you in the market.
+
+Delivery Infrastructure (How you deliver): Channels and partnerships must align to ensure seamless access to your offering. For instance, a SaaS company might leverage cloud platforms for instant scalability, while a luxury brand prioritizes exclusive retail partnerships.
+
+Customer Lifecycle Dynamics:
+
+Acquisition: How do users discover you? Channels like organic search (SEO), targeted ads, or influencer partnerships must map to your customer segments’ behaviors.
+
+Activation: Do first-time users experience immediate value? A fitness app, for example, might use onboarding tutorials to convert sign-ups into active users.
+
+Retention: Is engagement sustained? Metrics like churn rate and CLV reveal whether your model fosters loyalty through features like personalized content or subscription perks.
+
+Referral: Do users become advocates? Incentivize sharing through referral programs or viral loops (e.g., Dropbox’s storage rewards).
+
+Revenue Architecture (How you monetize): Align pricing models (subscriptions, freemium tiers) with customer willingness-to-pay. For instance, a niche market might sustain premium pricing, while a mass-market product prioritizes volume.
+
+Cost Symmetry: Every activity—from R&D to customer support—must balance against revenue streams. A low-cost airline, for example, optimizes for operational efficiency to maintain profitability.
+
+Strategic Imperatives for Modern Business Models
+
+Systemic Integration: Ohmae’s “3C’s” (Customer, Competitor, Company) remind us that acquisition channels and value propositions must adapt to shifting market realities. For instance, a retailer might pivot from brick-and-mortar to hybrid models post-pandemic.
+
+Data-Driven Iteration: Use AARRR metrics to identify leaks in the funnel. If activation rates lag, refine onboarding; if referrals stagnate, enhance shareability.
+
+Scalability through Partnerships: Key partners (e.g., tech vendors, logistics providers) can reduce overhead while expanding reach—critical for transitioning from niche to mass markets.
+
+By framing each component as a strategic variable rather than a fixed element, businesses can continuously adapt to disruptions—a necessity in Ohmae’s vision of fluid, customer-first strategy.
+    """]
+      ],
+      [in_verbatim]
+    )
+
+    gr.Examples(
+      [
+        [
+          """Create marketing campaign that can improve customer acquisition, activation, retention and referral for this persona:
+Low APR and great customer service. I would highly recommend if you’re looking for a great credit card company and looking to rebuild your credit. I have had my credit limit increased annually and the annual fee is very low.
+    """]
+      ],
+      [in_question]
+    )
+    btn_recommend = gr.Button("Reasoning")
+    btn_recommend.click(fn=reasoning, inputs=[in_verbatim, in_question], outputs=out_product)
 
 
 demo.launch(allowed_paths=["./xgb","./ts"])

graphrag.py

@@ -0,0 +1,93 @@
+
+import os
+
+
+"""
+from langchain_openai import ChatOpenAI
+llm = ChatOpenAI(temperature=0, model_name="gpt-4-turbo")
+
+from langchain_ollama.llms import OllamaLLM
+llm = OllamaLLM(temperature=0,model="llama3.2")
+"""
+
+from typing import List, Optional
+
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+
+# SEE: https://huggingface.co/docs/hub/security-tokens
+# We just need a token with read permissions for this demo
+HF_TOKEN: Optional[str] = os.getenv("HF_TOKEN")
+
+llm = HuggingFaceInferenceAPI(
+    temperature=0,
+    model_name="meta-llama/Llama-3.2-1B"
+)
+
+import os
+import networkx as nx
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+
+from langchain_experimental.graph_transformers import LLMGraphTransformer
+from langchain.chains import GraphQAChain
+from langchain_core.documents import Document
+from langchain_community.graphs.networkx_graph import NetworkxEntityGraph
+
+
+
+customer="Low APR and great customer service. I would highly recommend if you’re looking for a great credit card company and looking to rebuild your credit. I have had my credit limit increased annually and the annual fee is very low."
+
+text="""
+A business model is a combination of things: it's what you sell, how you deliver it, how you acquire customers, and how you make money from them.
+
+Acquisition: how do users become aware of you?
+Activation: Do drive-by visitors subscribe and use? 
+Retention:  does a one-time user become engaged?
+Referral: Do users tell others?
+Revenue: How do you make money?
+"""
+question=f"Create marketing campaign that can improve customer acquisition, activation, retention and referral for this persona: {customer}"
+def knowledge_graph(text):
+    documents = [Document(page_content=text)]
+    llm_transformer_filtered = LLMGraphTransformer(llm=llm,
+    # allowed_nodes=["Need", "Issue", "Product"],
+    # allowed_relationships=["WANT", "WITH", "USING", "RECOMMEND"],)
+    graph_documents_filtered = llm_transformer_filtered.convert_to_graph_documents(documents)
+    graph = NetworkxEntityGraph()
+
+    for node in graph_documents_filtered[0].nodes:
+        graph.add_node(node.id)
+
+    for edge in graph_documents_filtered[0].relationships:
+        graph._graph.add_edge(
+            edge.source.id,
+            edge.target.id,
+            relation=edge.type
+        )
+
+    return graph, graph_documents_filtered
+
+
+def reasoning(text, question):
+  try:
+    print("Generate Knowledgegraph...")
+    graph, graph_documents_filtered = knowledge_graph(text)
+
+    print("GraphQAChain...")
+    graph_rag = GraphQAChain.from_llm(
+      llm=llm,
+      graph=graph,
+      verbose=True
+    )
+
+    print("Answering through GraphQAChain...")
+    answer = graph_rag.invoke(question)
+    return answer
+
+  except Exception as e:
+    print(f"An error occurred in process_text: {str(e)}")
+    import traceback
+    traceback.print_exc()
+    return str(e)
+

requirements.txt

@@ -9,4 +9,17 @@ openai==1.61.0
 dspy
 llama-index
 faiss-cpu
-tavily-python
+tavily-python
+
+llama-index-llms-huggingface-api
+huggingface_hub[inference]
+
+networkx
+matplotlib
+langchain-experimental
+#langchain-groq
+langchain-community
+pandas
+#gradio-client
+pillow
+numpy