app.py

import gradio as gr
import openai
import json
from graphviz import Digraph
from PIL import Image
import io
import requests
from bs4 import BeautifulSoup

# Function to scrape text from a website
def scrape_text_from_url(url):
    response = requests.get(url)
    if response.status_code != 200:
        return "Error: Could not retrieve content from URL."
    soup = BeautifulSoup(response.text, "html.parser")
    paragraphs = soup.find_all("p")
    text = " ".join([p.get_text() for p in paragraphs])
    return text

def generate_knowledge_graph(api_key, user_input):
    openai.api_key = api_key

    # Check if input is URL or text
    if user_input.startswith("http://") or user_input.startswith("https://"):
        user_input = scrape_text_from_url(user_input)

    # Chamar a API da OpenAI
    completion = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-16k",
        messages=[
            {
                "role": "user",
                "content": f"Help me understand following by describing as a detailed knowledge graph: {user_input}",
            }
        ],
        functions=[
            {
                "name": "knowledge_graph",
                "description": "Generate a knowledge graph with entities and relationships. Use the colors to help differentiate between different node or edge types/categories. Always provide light pastel colors that work well with black font.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "metadata": {
                            "type": "object",
                            "properties": {
                                "createdDate": {"type": "string"},
                                "lastUpdated": {"type": "string"},
                                "description": {"type": "string"},
                            },
                        },
                        "nodes": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "id": {"type": "string"},
                                    "label": {"type": "string"},
                                    "type": {"type": "string"},
                                    "color": {"type": "string"},  # Added color property
                                    "properties": {
                                        "type": "object",
                                        "description": "Additional attributes for the node",
                                    },
                                },
                                "required": [
                                    "id",
                                    "label",
                                    "type",
                                    "color",
                                ],  # Added color to required
                            },
                        },
                        "edges": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "from": {"type": "string"},
                                    "to": {"type": "string"},
                                    "relationship": {"type": "string"},
                                    "direction": {"type": "string"},
                                    "color": {"type": "string"},  # Added color property
                                    "properties": {
                                        "type": "object",
                                        "description": "Additional attributes for the edge",
                                    },
                                },
                                "required": [
                                    "from",
                                    "to",
                                    "relationship",
                                    "color",
                                ],  # Added color to required
                            },
                        },
                    },
                    "required": ["nodes", "edges"],
                },
            }
        ],
        function_call={"name": "knowledge_graph"},
    )

    response_data = completion.choices[0]["message"]["function_call"]["arguments"]
    # Debugging: Print the type and value of response_data
    print(f"Type of response_data: {type(response_data)}")
    print(f"Value of response_data: {response_data}")

    try:
        # Convert to dictionary if it's a string
        if isinstance(response_data, str):
            response_data = json.loads(response_data)
    except json.JSONDecodeError as e:
        print(f"JSON Decode Error: {e}")
        return "Error in decoding JSON"
    
    # Convert to dictionary if it's a string
    if isinstance(response_data, str):
        response_data = json.loads(response_data)

    # Visualizar o conhecimento usando Graphviz
    dot = Digraph(comment="Knowledge Graph", format='png')
    dot.attr(dpi='300')
    dot.attr(bgcolor='white')

    # Estilizar os nós
    dot.attr('node', shape='box', style='filled', fillcolor='lightblue', fontcolor='black')

    for node in response_data.get("nodes", []):
        dot.node(node["id"], f"{node['label']} ({node['type']})", color=node.get("color", "lightblue"))

    # Estilizar as arestas
    dot.attr('edge', color='black', fontcolor='black')

    for edge in response_data.get("edges", []):
        dot.edge(edge["from"], edge["to"], label=edge["relationship"], color=edge.get("color", "black"))

    # Renderizar para o formato PNG
    image_data = dot.pipe()
    image = Image.open(io.BytesIO(image_data))

    return image

# Define a title and description for the Gradio interface using Markdown
title_and_description = """
# Instagraph - Knowledge Graph Generator

Enter your OpenAI API Key and a question, and let the AI create a detailed knowledge graph for you.

**New Feature:** You can now input a URL to scrape text for generating the knowledge graph. Rest assured, the code is open for your inspection to ensure safety.
"""

with gr.Blocks() as app:
    gr.Markdown(title_and_description)
    
    with gr.Row():
        with gr.Column():
            result_image = gr.Image(type="pil", label="Generated Knowledge Graph")
            
    with gr.Row():
        with gr.Column():
            api_key = gr.Textbox(label="OpenAI API Key", type="password")
            user_input = gr.Textbox(label="User Input for Graph or URL", type="text")
            run_btn = gr.Button("Generate")
            
    run_btn.click(
        generate_knowledge_graph,
        inputs=[api_key, user_input],
        outputs=[result_image]
    )

# Enable queueing system for multiple users
app.queue(concurrency_count=10)

print("Iniciando a interface Gradio...")
app.launch()