ea4all-gradio-mcp-hackathon-submission

.gitignore

@@ -0,0 +1,179 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+.DS_Store
+
+# Projects hosted @Hugging Face
+../ea4all-agentic-live/    # EA4ALL Agentic Live
+../ea4all-agentic-system/  # EA4ALL Agentic System
+../ea4all-agentic-staging/ # EA4ALL Agentic Build/Test
+
+# EA4ALL artifacts
+*.wav
+*.png
+*.faiss
+*.pkl
+togaf_runway_*
+
+# Langchain / Langgraph
+.langgraph_api/
+lgs-dev-start
+
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.envrc
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.12.10
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:/tmp/gradio:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME
+
+# Install graphviz dependency
+USER root
+RUN apt-get clean
+RUN apt-get update --fix-missing \
+    && xargs -a packages.txt apt-get install -y \
+    && apt-get clean
+USER user

README.md

@@ -1,14 +1,123 @@
 ---
-title: Enterprise Architecture For All
-emoji: 🐨
-colorFrom: yellow
-colorTo: green
+title: Enterprise Architecture for All
+emoji: 👁
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 5.33.1
+sdk_version: 5.32.1
+python_version: 3.12.10
 app_file: app.py
 pinned: false
-license: mit
+license: apache-2.0
 short_description: EA4ALL Gradio MCP Server
+tags:
+    - mcp-server-track
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Architect Agentic Companion
+
+![Agent System Container](ea4all/images/ea4all_architecture.png)
+
+
+## Background
+
+- `Trigger`: How disruptive may Generative AI be for Enterprise Architecture Capability (People, Process and Tools)?
+- `Motivation`: Master GenAI while disrupting Enterprise Architecture to empower individuals and organisations with ability to harness EA value and make people lives better, safer and more efficient.
+- `Ability`: Exploit my carrer background and skillset across system development, business accumen, innovation and architecture to accelerate GenAI exploration while learning new things.
+
+> That's how the `EA4ALL-Agentic system` was born and ever since continuously evolving to build an ecosystem of **Architects Agent partners**.
+
+## Benefits
+
+- `Empower individuals with Knowledge`: understand and talk about Business and Technology strategy, IT landscape, Architectue Artefacts in a single click of button.
+- `Increase efficiency and productivity`: generate a documented architecture with diagram, model and descriptions. Accelerate Business Requirement identification and translation to Target Reference Architecture. Automated steps and reduced times for task execution.
+- `Improve agility`: plan, execute, review and iterate over EA inputs and outputs. Increase the ability to adapt, transform and execute at pace and scale in response to changes in strategy, threats and opportunities.
+- `Increase collaboration`: democratise architecture work and knowledge with anyone using natural language.
+- `Cost optimisation`: intelligent allocation of architects time for valuable business tasks.
+- `Business Growth`: create / re-use of (new) products and services, and people experience enhancements.
+- `Resilience`: assess solution are secured by design, poses any risk and how to mitigate, apply best-practices.
+- `Streamline`: the process of managing and utilizsng architectural knowledge and tools in a user-friendly way.
+
+## Knowledge context
+
+Synthetic datasets are used to exemplify the Agentic System capabilities.
+
+### IT Landscape Question and Answering
+
+    - Application name
+        - Business fit: appropriate, inadequate, perfect
+        - Technical fit: adequate, insufficient, perfect
+        - Business_criticality: operational, medium, high, critical
+        - Roadmap: maintain, invest, divers
+        - Architect responsible
+        - Hosting: user device, on-premise, IaaS, SaaS
+        - Business capability
+        - Business domain
+        - Description  
+
+    - Bring Your Own Data: upload your own IT landscape data
+        - Application Portfolio Management
+            - xlsx tabular format
+            - first row (header) with fields name (colums)
+    
+### Architecture Diagram Visual Question and Answering
+
+    - Architecture Visual Artefacts
+        - jpeg, png
+
+        **Disclaimer**
+                - Your data & image are not accessible or shared with anyone else nor used for training purpose.
+                - EA4ALL-VQA Agent should be used ONLY FOR Architecture Diagram images.
+                - This feature should NOT BE USED to process inappropriate content.
+
+### Reference Architecture Generation
+
+    - Clock in/out Use-case
+
+## Log / Traceability
+
+    For purpose of continuous improvement, agentic workflows are logged in. 
+
+## Architecture
+
+<italic>Core architecture built upon Python, Langchain, Langgraph, Langsmith, and Gradio.<italic>
+
+    - Python
+        - Pandas
+        - Langchain
+        - Langgraph
+        - Huggingface
+        - CrewAI
+
+    - RAG (Retrieval Augmented Generation)
+        - Vectorstore
+
+    - Prompt Engineering
+        - Strategy & tactics: Task / Sub-tasks
+        - Agentic Workflow
+
+    - Models: 
+        - OpenAI
+        - Meta/Llama
+        - Google Gemini
+    
+    - Hierarchical-Agent-Teams: 
+        - Tabular-question-answering over your own document
+        - Supervisor
+        - Visual Questions Answering 
+        - Diagram Component Analysis
+        - Risk & Vulnerability and Mitigation options
+        - Well-Architecture Design Assessment
+        - Vision and Target Architecture
+        - Architect Demand Management
+    
+    - User Interface
+        - Gradio
+
+    - Observability & Evaluation
+        - Langsmith
+
+    - Hosting
+        - Huggingface Space
+    
+Check out the configuration reference at [spaces-config-reference](https://huggingface.co/docs/hub/spaces-config-reference)

app.py

@@ -0,0 +1,32 @@
+#import gradio as gr
+
+#def greet(name):
+#    return "Hello " + name + "!!"
+
+#demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+#demo.launch()
+
+##version 2025-05-17
+# LangChain environment variables
+from pathlib import Path
+import sys, os
+
+if __name__ == '__main__':
+
+    current_path = Path.cwd()
+    sys.path.append(os.path.join(str(current_path), 'ea4all', 'src'))
+    
+    print (f"Current path: {current_path} \n Parent {current_path.parent} \n Root path: {str(Path.cwd())}")
+
+    #Set environment variables for build deployment (local run)
+    ea4all_stage = os.environ["EA4ALL_ENV"]
+    if ea4all_stage in ('MCP'):
+        project_name = "ea4all-gradio-agent-mcp-hackathon"
+        runname = "ea4all-gradio-agent-mcp-hackathon-run"
+        os.environ["LANGCHAIN_PROJECT"] = project_name  # Optional: "default" is used if not set
+        os.environ['LANGCHAIN_RUNNAME'] = runname
+        os.environ['EA4ALL_ENV'] = ea4all_stage
+
+    #ea4all-agent-entry-point
+    from ea4all.__main__ import main
+    main()

ea4all/.gitattributes

@@ -0,0 +1 @@
+*.png filter=lfs diff=lfs merge=lfs -text

ea4all/__main__.py

@@ -0,0 +1,21 @@
+from ea4all import ea4all_mcp as e4m
+import os
+
+def main() -> None:
+    #Launch UI
+    try:
+        e4m.ea4all_mcp.launch(
+            server_name=os.getenv("GRADIO_SERVER_NAME","0.0.0.0"),
+            server_port=None,
+            debug=os.getenv("GRADIO_DEBUG", "True").lower() in ("true", "1", "yes"),
+            ssr_mode=False,
+            mcp_server=True,
+            inbrowser=os.getenv("GRADIO_INBROWSER", "True").lower() in ("true", "1", "yes"),
+            #auth=("ea4all", "ea4a@@"),
+            auth_message="Please login with your credentials. Under development, will be public soon.",
+        )
+    except Exception as e:
+        print(f"Error loading: {e}")
+    
+if __name__ == "__main__":
+    main()

ea4all/ea4all_mcp.py

@@ -0,0 +1,386 @@
+#CHANGELOG: 2025-06-04
+## Gradio Agents MCP Hackathon: retrofit to expose EA4ALL Agentic System Agents only
+## Greetings message not working
+## UI exposing too much tools, need to be refactored
+from langchain.callbacks.tracers import LangChainTracer
+from langchain.callbacks.tracers.langchain import wait_for_all_tracers
+from langchain_core.messages import HumanMessage
+from langchain_core.runnables import RunnableConfig
+
+from ea4all.src.shared.configuration import BaseConfiguration, APM_MOCK_QNA, PMO_MOCK_QNA
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration as gra
+from ea4all.src.ea4all_apm.graph import apm_graph
+from ea4all.src.ea4all_vqa.graph import diagram_graph
+from ea4all.src.ea4all_gra.graph import togaf_graph
+from ea4all.src.ea4all_indexer.graph import indexer_graph
+from ea4all.src.shared.utils import (
+    get_relevant_questions, 
+    get_vqa_examples, 
+    _join_paths,
+    EA4ALL_ARCHITECTURE,
+    EA4ALL_PODCAST,
+)
+
+#from ea4all.src.pmo_crew.crew_runner import run_pmo_crew
+
+from typing import AsyncGenerator
+import gradio as gr
+from gradio import ChatMessage
+import os
+import uuid
+import time
+from PIL import Image
+
+from ea4all.utils.utils import (
+    UIUtils,
+    ea4all_agent_init, get_image,
+    get_question_diagram_from_example,
+    on_image_update
+)
+
+TITLE =  """
+    # Title
+        
+    **Explore, Share, Together:** harness the value of `Enterprise Architecture in the era of Generative AI` with ready-to-use MCP Tools.\n
+
+    ## Overview
+    """
+
+#Set LangSmith project
+tracer = LangChainTracer(project_name=os.getenv('LANGCHAIN_PROJECT'))
+
+config = RunnableConfig(
+        run_name = os.getenv('LANGCHAIN_RUNNAME', "ea4all-gradio-agent-mcp-hackathon-run"), 
+        tags = [os.getenv('EA4ALL_ENV', "MCP")],
+        callbacks = [tracer],
+        recursion_limit = 25,
+        configurable = {"thread_id": uuid.uuid4()},
+        #stream_mode = "messages"
+)
+
+async def call_indexer_apm(config: RunnableConfig):
+    response = await indexer_graph.ainvoke(input={"docs":[]}, config=config)
+    return response
+
+#ea4all-qna-agent-conversational-with-memory
+async def run_qna_agentic_system(question: str) -> AsyncGenerator[list, None]:
+    """
+    description: 
+        Handles conversational Q&A for the Application Landscape using an agentic system.
+    Args:
+        question (str): The user's question or message.
+        request (gr.Request): The Gradio request object for user identification.
+    Returns:
+        reponse: Response to user's architectural question.
+    """
+
+    format_response = ""
+    chat_memory = []
+    if not question:
+        format_response = "Hi, how are you today? To start using the EA4ALL MCP Tool, provide the required Inputs!"
+        chat_memory.append(ChatMessage(role="assistant", content=format_response))
+    else:
+        index = await call_indexer_apm(config) #call indexer to update the index
+        response = await apm_graph.ainvoke({"question": question}, config=config)
+        chat_memory.append(ChatMessage(role="assistant", content=response['generation']))
+
+    yield chat_memory
+
+#Trigger Solution Architecture Diagram QnA
+async def run_vqa_agentic_system(question: str, diagram: str, request: gr.Request) -> AsyncGenerator[list, None]:
+    """
+    description: 
+        Handles Visual Question Answering (VQA) for uploaded architecture diagrams.
+    Args:
+        question (str): User's question about the Architecture Diagram.
+        diagram (str): Path to the diagram file.
+    Returns:
+        response: Response to user's question.
+    """
+
+    #capture user ip
+    #ea4all_user = e4u.get_user_identification(request)
+
+    """Handle file uploads and validate their types."""
+    allowed_file_types = ('JPEG', 'PNG')
+
+    message = {
+        'text': question,
+        'files': [diagram] if isinstance(diagram, str) else diagram
+    }
+
+    print("---CALLING VISUAL QUESTION ANSWERING AGENTIC SYSTEM---")
+    print(f"Prompt: {message}")
+
+    chat_memory = []
+    if message['files'] == []:
+        chat_memory.append(ChatMessage(role="assistant", content="Please upload an Architecture PNG, JPEG diagram to start!"))
+        yield chat_memory
+    else:
+        diagram = message['files'][-1] ##chat_memory[-1]['content'][-1]        
+        msg = message['text'] ##chat_memory[-2]['content']
+        print(f"---DIAGRAM: {diagram}---")
+        try:
+            if msg == "":
+                msg = "Please describe this diagram."
+
+            with Image.open(diagram) as diagram_:
+                if diagram_.format not in allowed_file_types:
+                    #chat_memory.append(ChatMessage(role="assistant", content="Invalid file type. Allowed file types are JPEG and PNG."))
+                    print(f"---DIAGRAM: {diagram.format} is not a valid file type. Allowed file types are JPEG and PNG.---")
+                #else:
+                #'vqa_image = e4u.get_raw_image(diagram) #MOVED into Graph
+
+                vqa_image = diagram
+                response = await diagram_graph.ainvoke({"question":msg, "image": vqa_image}, config)
+                chat_memory.append(ChatMessage(role="assistant", content=response['messages'][-1].content if len(response['messages']) else response['safety_status']['description']))
+                
+                yield chat_memory
+
+        except Exception as e:
+            yield (e.args[-1])
+
+#Run Togaf Agentic System
+async def run_reference_architecture_agentic_system(business_query: str) -> AsyncGenerator[list, str]:
+    """
+    description: 
+        Generates a reference architecture blueprint based on a business requirement using the TOGAF agentic system.
+    Args:
+        business_query (str): Description of a business problem / requirement.
+    Returns:
+        response: High-level architecture blueprint and target diagram.
+    """
+
+    if len(business_query) < 20:
+        agent_response = "Please provide a valid Business Requirement content to start!"
+        yield([agent_response, None])
+    else: 
+        inputs = {"business_query": [{"role": "user", "content": business_query}]} #user response
+        index = await call_indexer_apm(config) #call indexer to update the index
+        response = await togaf_graph.ainvoke(
+            input=inputs, 
+            config=config
+        ) #astream not loading the graph
+        vision_target = response['vision_target']
+        architecture_runway = response['architecture_runway']
+        yield [vision_target, architecture_runway]
+
+async def run_pmo_agentic_system(question:str) -> AsyncGenerator[list, None]:
+    """
+    description: 
+        Answers questions about Project Portfolio Management and Architect Demand Management.
+    Args:
+        question (str): The user's question about project portfolio or resource management.
+        chat_memory: The conversation history.
+    Returns:
+        response: Architect Demand Allocation Report
+    """
+
+    format_response = ""
+    chat_memory = []
+    if not question:
+        format_response = "Hi, how are you today? To start our conversation, please chat your message!"
+        chat_memory.append(ChatMessage(role="assistant", content=format_response))
+        yield chat_memory
+
+    if not chat_memory:
+        chat_memory.append(ChatMessage(role="user", content=question))
+        yield chat_memory
+
+    inputs = {
+        "question": question,
+        "verbose": True,  # optional flags
+    }
+    
+    #yield run_pmo_crew(inputs)
+
+#Blocks w/ ChatInterface, BYOD, About
+with gr.Blocks(title="Your ArchitectGPT",fill_height=True, fill_width=True) as ea4all_mcp:
+
+    agentic_pmo_desc="""
+        Hi, 
+        Provide project resource estimation for architecture work based on business requirements, skillset, 
+        architects allocation, and any other relevant information to enable successful project solution delivery."""
+    
+    agentic_qna_desc="""
+        Hi,
+        Improve Architect's ability to share knowledge, and provide valuable insights from IT landscape using natural language answering questions related to Enterprise Architecture, Technology, plus the following IT Landscape sample dataset: """
+
+    agentic_vqa_desc="""
+    Hi, 
+    Gain rapid knowledge and insights translating image to meaningful description. 
+    """
+
+    agentic_togaf_desc="""
+        Hi,
+        in a click of button create a reference architecture that serves as a blueprint for designing and implementing IT solutions.
+        Standardise, increase efficiency and productivity to architecture solution development.
+        Generate context-specific reference and minimal viable architectures to support business and IT strategy and digital transformation.
+        Streamline the architecture operating model, taking the best of agentic workflows and architects working together.
+    """
+    
+    #Wrapper for functions not to be exposed by the MCP Server
+    wrapper = gr.Button(visible=False) #wrapper.click(UIUtils.ea4all_about, show_api=False,)
+    wrapper1 = gr.Button(visible=False) #wrapper1.click(init_dbr, show_api=False,)
+
+    #EA4ALL-Agentic system menu
+    with gr.Tabs(selected="how_to") as tabs:
+        with gr.Tab(label="Architect Demand Management", visible=False):
+            with gr.Tab(label="Architect Project Planning", id="pmo_qna_1"):
+                ea4all_pmo_description = gr.Markdown(value=agentic_pmo_desc)
+                pmo_chatbot = gr.Chatbot(
+                    label="EA4ALL your AI Demand Management Architect Companion", type="messages",
+                    max_height=160,
+                    layout="bubble",
+                )
+                pmo_prompt = gr.Textbox(lines=1, show_label=False, max_lines=1, submit_btn=True, stop_btn=True,autofocus=True, placeholder="Type your message here or select an example...")
+                with gr.Accordion("Open for question examples", open=False):
+                    pmo_examples = gr.Dropdown(get_relevant_questions(PMO_MOCK_QNA), value=None,label="Questions", interactive=True)
+                gr.ClearButton([pmo_chatbot,pmo_prompt], value="Clear", size="sm", visible=False)
+            with gr.Tab(label="Project Portfolio Sample Dataset", id="id_pmo_ds"):
+                pmo_df = gr.Dataframe()
+        with gr.Tab(label="Application Landscape QnA"):
+            with gr.Tabs() as tabs_apm_qna:
+                with gr.Tab(label="Connect, Explore, Together", id="app_qna_1"):
+                    ea4all_agent_metadata = gr.Markdown(value=agentic_qna_desc)
+                    ea4all_chatbot = gr.Chatbot(
+                        label="EA4ALL your AI Landscape Architect Companion", type="messages",
+                        max_height=160,
+                        layout="bubble",
+                    )
+                    qna_prompt = gr.Textbox(lines=1, show_label=False, max_lines=1, submit_btn=True, autofocus=True, placeholder="Type your message here or select an example...")
+                    with gr.Accordion("Open for question examples", open=False):
+                        qna_examples = gr.Dropdown(get_relevant_questions(APM_MOCK_QNA),label="Questions", interactive=True)
+                    gr.ClearButton([ea4all_chatbot,qna_prompt, qna_examples], value="Clear", size="sm", visible=True)
+                with gr.Tab(label="Sample Dataset", id="id_apm_ds"):
+                    apm_df = gr.Dataframe()
+        with gr.Tab(label="Diagram Question and Answering"):
+            gr.Markdown(value=agentic_vqa_desc)
+            ea4all_vqa = gr.Chatbot(
+                label="EA4ALL your AI Multimodal Architect Companion", type="messages",
+                max_height=160,
+                layout="bubble",
+            )
+            vqa_prompt = gr.Textbox(lines=1, show_label=False, max_lines=1, submit_btn=True, stop_btn=True,autofocus=True, placeholder="Type your message here and upload your diagram...")
+            vqa_image = gr.Image(
+                label="Architecture Diagram",
+                type="filepath",
+                format="jpeg, png",
+                interactive=True,
+                show_download_button=False,
+                show_share_button=False,
+                visible=True,
+            )
+            #vqa_prompt = gr.MultimodalTextbox(interactive=True, show_label=False, submit_btn=True, stop_btn=True, autofocus=True, placeholder="Upload your diagram and type your message or select an example...")
+            with gr.Accordion("Open for question examples", open=False):
+                vqa_examples = gr.Dropdown(get_vqa_examples(), value=0,label="Diagram and Questions", interactive=True)
+            gr.ClearButton([ea4all_vqa,vqa_prompt,vqa_image, vqa_examples], value="Clear", size="sm", visible=True)
+        with gr.Tab(label="Reference Architecture", id="id_refarch"):
+            dbr_text=gr.TextArea(label="Business Problem Sample", value="Provide a Business Problem / Requirement Specification or select an example provided.", lines=14, interactive=True)
+            togaf_vision=gr.Markdown(value='### Reference Architecture: Vision and Target')
+            architecture_runway=gr.Image(label="Target Architecture Runway",interactive=False,visible=False)            
+            with gr.Row():
+                dbr_file=gr.File(
+                    value=_join_paths(BaseConfiguration.ea4all_store, gra.dbr_mock),
+                    label="Business Requirement", 
+                    height=35, 
+                    show_label=False, 
+                    file_count="single", 
+                    file_types=['text'], 
+                    interactive=True,
+                    type='binary',
+                    visible=False
+                )
+                dbr_run=gr.Button(scale=None,value="Run Reference Architecture")
+                dbr_cls=gr.ClearButton([togaf_vision, architecture_runway])
+        with gr.Tab(label="Overview", id="how_to"):
+            gr.Markdown(value=TITLE)
+            gr.Image(
+                get_image(EA4ALL_ARCHITECTURE),
+                show_download_button=False,
+                container=False,
+                show_share_button=False,
+                )
+            gr.Markdown(
+                """
+                - `Empower individuals with Knowledge`: understand and talk about Business and Technology strategy, IT landscape, Architectue Artefacts in a single click of button.
+                - `Increase efficiency and productivity`: generate a documented architecture with diagram, model and descriptions. Accelerate Business Requirement identification and translation to Target Reference Architecture. Automated steps and reduced times for task execution.
+                - `Improve agility`: plan, execute, review and iterate over EA inputs and outputs. Increase the ability to adapt, transform and execute at pace and scale in response to changes in strategy, threats and opportunities.
+                - `Increase collaboration`: democratise architecture work and knowledge with anyone using natural language.
+
+                ### Knowledge Context
+
+                Synthetic datasets are used to exemplify the Agentic System capabilities.
+
+                ### IT Landscape Question and Answering
+
+                    - Application name
+                        - Business fit: appropriate, inadequate, perfect
+                        - Technical fit: adequate, insufficient, perfect
+                        - Business_criticality: operational, medium, high, critical
+                        - Roadmap: maintain, invest, divers
+                        - Architect responsible
+                        - Hosting: user device, on-premise, IaaS, SaaS
+                        - Business capability
+                        - Business domain
+                        - Description  
+
+                    
+                ### Architecture Diagram Visual Question and Answering
+
+                    - Architecture Visual Artefacts
+                        - jpeg, png
+
+                        **Disclaimer**
+                                - Your data & image are not accessible or shared with anyone else nor used for training purpose.
+                                - EA4ALL-VQA Agent should be used ONLY FOR Architecture Diagram images.
+                                - This feature should NOT BE USED to process inappropriate content.
+
+                ### Reference Architecture Generation
+
+                    - Clock in/out Use-case
+                """
+            )
+
+    #Avoid exposing API /Dependency?
+    #dbr_text.change(wrapper1.click(init_dbr,show_api=False)) NOT working
+
+    #Togaf upload file
+    #dbr_file.clear(unload_dbr,outputs=dbr_text)
+    #dbr_file.change(on_dbrtext,inputs=dbr_file,outputs=dbr_text)
+    dbr_file.change(UIUtils.load_dbr,inputs=dbr_file, outputs=dbr_text, show_api=False)
+    #dbr_cls.click(off_dbrtext,outputs=[dbr_text, tabs_togaf, tab_diagram])
+
+    #Refactored ea4all_chatbot / vqa_chatbot (ChatInterface -> Chatbot)
+    qna_prompt.submit(run_qna_agentic_system,[qna_prompt],ea4all_chatbot, api_name="landscape_answering_agent")
+    #qna_prompt.submit(lambda: "", None, [qna_prompt])
+    #ea4all_chatbot.like(fn=get_user_feedback)
+    qna_examples.input(lambda value: value, qna_examples, qna_prompt, show_api=False)
+
+    #Execute Reference Architecture
+    dbr_run.click(run_reference_architecture_agentic_system,show_progress='full',inputs=[dbr_text],outputs=[togaf_vision, architecture_runway], api_name="togaf_blueprint_generation")
+    architecture_runway.change(on_image_update, inputs=architecture_runway, outputs=architecture_runway, show_api=False)    
+
+    #chat_msg = vqa_prompt.submit(UIUtils.add_message, [vqa_prompt, vqa_image], [vqa_prompt, ea4all_vqa], show_api=False)
+    #bot_msg = chat_msg.then(run_vqa_agentic_system, [vqa_prompt, vqa_image], ea4all_vqa, api_name="diagram_answering_agent")
+    vqa_prompt.submit(run_vqa_agentic_system,[vqa_prompt, vqa_image], ea4all_vqa, api_name="diagram_answering_agent")
+    
+    #ea4all_vqa.like(fn=get_user_feedback)
+    vqa_examples.input(get_question_diagram_from_example, vqa_examples, outputs=[vqa_prompt, vqa_image], show_api=False)
+
+    #Invoke CrewAI PMO Agentic System
+    pmo_prompt.submit(run_pmo_agentic_system,[pmo_prompt],pmo_chatbot, api_name="architect_demand_agent", show_api=False)
+    pmo_prompt.submit(lambda: "", None, [pmo_prompt], show_api=False)
+    #pmo_examples.input(lambda value: value, pmo_examples, pmo_prompt)
+
+    #Set initial state of apm and llm
+    ea4all_mcp.load(ea4all_agent_init, outputs=[
+        ea4all_agent_metadata,
+        ea4all_chatbot, 
+        ea4all_vqa, 
+        pmo_chatbot, 
+        apm_df, 
+        pmo_df, 
+        dbr_text
+        ], 
+        show_api=False)

ea4all/ea4all_store/apm_qna_mock.txt

@@ -0,0 +1,4 @@
+What are the simplification opportunities within the collaboration landscape?
+Who can I talk to about innovation?
+What applications support marketing domain?
+How can Cloud Assessment Framework increase cloud-based landscape benefits?

ea4all/ea4all_store/dbr.txt

@@ -0,0 +1,32 @@
+Purpose of this document 
+
+The purpose of this document is to provide an overview of the project and specifically detail the business requirements for the project across the relevant business and market areas. 
+
+The requirements and solution will be agreed with the project sponsor (s) through formal review and sign off of this document. 
+Once signed off it will provide input to the subsequent design and development phases of the project.
+
+Context 
+ (These areas can be taken from the Brief/ PID as appropriate)
+Background
+• Change in external scenario - more integrated supervisory organs;
+  
+Why we need this project 
+To make it possible to control the schedule of work on employees that are legally required to. 
+
+Expected Business Outcome / Objective (Goal)    
+To implement the Electronic Timecard in all company business units to the public that are subject to the schedule of work and by that, reduce the number and impact of worktime related lawsuits
+
+Project Objectives
+Be compliance with current regulation regarding Timestamp with all employees with work schedule.
+
+Ref,Feature,Description,MoSCoW
+A,Input,Registration of ins/outs of employees  at the system,M
+G,New Worktime,Creation of new Time schedules for employees,M
+
+
+Actor Catalogue 
+
+Name, Description,Goals 
+Employees,Employee of company under time control,To register ins and outs
+Manager,Employees first manager,To approve JMLs and monthly activities regarding Time management of employees
+HRSS,Key users of Shared Services of Human Resources,To manage the back end of time system

ea4all/ea4all_store/ea4all-portfolio-management.csv

@@ -0,0 +1,31 @@
+Project Name,Problem Statement,Requestor,Project Type,Complexity_Risk,Value_Benefit,Delivery Manager,Business Analyst,Project Sponsor,Line of Business,Timeline - Start,Timeline - End,Architect,Estimated Effort (Days/Month),Status
+Procurement Target Operating Model,"The proposed project seeks to analyze the current procurement processes of our company and identify areas of inefficiency, particularly in the vendor management life cycle. This analysis will involve a comprehensive review of our existing supplier relationships, evaluation of vendor performance metrics, and comparison of industry benchmarks. The objective of this initiative is to streamline our procurement processes, reduce costs, and enhance our partnerships with key suppliers.",Michael Scott,Enhance,medium,medium_high,Kelly Kapoor,Creed Bratton,Jo Bennett,Procurement,2024-06-17,2024-09-15,alexandre.procurement,10,Closed
+IT Comms Channels,"This document outlines the stakeholder identification process for a new IT project, including the roles and responsibilities of project sponsors, customers, developers, and end-users. It details the communication channels and expectations for each stakeholder group, ensuring that all parties are informed and engaged throughout the project lifecycle.",Pam Beesly,New Build,low,medium,Kelly Kapoor,Phyllis Vance,Jo Bennett,IT,2024-09-01,2024-11-30,alexandre.it,5,Closed
+Customer-centric PMO Framework,"To develop a customer-centric project management framework that aligns business objectives with stakeholder expectations and employee capabilities, we will assess current processes, identify areas of inefficiency, and implement process improvements that enhance collaboration and data-driven decision making.",Michael Scott,New Build,low,medium,Ryan Howard,Phyllis Vance,Holly Flax,Project Management,2024-09-19,2024-12-18,alexandre.pmo,9,Closed
+Market Channel Optimisation,"The project will involve gathering data on customer preferences and analyzing sales trends to determine the most effective marketing channels. This will be achieved by conducting market research, interviewing key stakeholders, and utilizing data analytics tools. The results will be presented to the project team and executive management to inform future business decisions.",Dwight Schrute,Enhance,low,low_medium,Angela Martin,Toby Flenderson,Jo Bennett,Marketing,2024-10-15,2025-01-13,alexandre.mkt,3,Closed
+Brain Activity Deep Learning Model,"The proposed project aims to investigate the efficacy of a novel deep learning algorithm for the detection of subtle changes in brain activity patterns associated with the early stages of Alzheimer's disease, utilizing fMRI data and integrating insights from graph theory.",Stanley Hudson,New Service,high,high,Ryan Howard,Toby Flenderson,Jan Levinson,AI COE,2024-11-01,2025-01-30,alexandre.ai,13,Closed
+Customer Satisfaction and Experience,"The goal of this project is to improve customer satisfaction by enhancing the user experience of our e-commerce platform. This will involve gathering feedback from customers, identifying pain points, and implementing changes to our website and mobile app.",Jim Halpert,Enhance,medium,medium,Oscar Martinez,Toby Flenderson,David Wallace,Customer Service,2024-11-22,2025-02-20,alexandre.csm,20,In Flight
+Customer Onboarding Optimisation,"Our company aims to redesign the customer onboarding process by improving the user experience, reducing the time it takes to complete, and increasing customer satisfaction. The new process will involve creating a self-service portal where customers can easily find the necessary information, submit required documents, and track their application status in real-time. This will not only enhance the customer's experience but also reduce the workload of our support team.",Michael Scott,Enhance,low,medium_high,Ryan Howard,Toby Flenderson,Holly Flax,Customer Service,2024-12-03,2025-03-03,alexandre.d2c,10,In Flight
+E-Commerce Website,"This document outlines the customer journey map for our new e-commerce website. It includes a detailed description of the customer's needs, pain points, and expectations at each stage of the purchasing process. This information will be used to identify opportunities for improvement and inform the design of the user interface.",Dwight Schrute,New Service,medium,high,Angela Martin,Creed Bratton,Jo Bennett,Digital to Consumer,2024-12-12,2025-03-12,alexandre.workplace,3,In Flight
+Booking Room optimisation,"The company aims to improve the customer experience by streamlining the process of booking rooms and making payments. The new system will integrate with existing CRM software, enabling staff to view customer history and preferences, and allowing for personalized marketing campaigns. The primary objective is to increase revenue through enhanced customer satisfaction and retention.",Dwight Schrute,Enhance,medium,medium_high,Kelly Kapoor,Darryl Philbin,Robert California,Digital Workplace,2025-01-16,2025-04-16,alexandre.ops,7,Discovery
+Blockchain Supply Chain solution,"The overarching goal of this project is to revolutionize the existing supply chain management system by implementing a decentralized blockchain-based solution. This system will enable real-time tracking of goods, reduce counterfeiting, and enhance transparency throughout the entire supply chain. Our primary objective is to create a more efficient and secure system, thereby improving customer satisfaction and business competitiveness.",Stanley Hudson,New Service,high,high,Ryan Howard,Creed Bratton,Jo Bennett,Operations,2025-01-16,2025-04-16,alexandre.ops,5,Discovery
+Order Delivery Optimisation,"The primary goal of this project is to increase customer satisfaction by reducing the time it takes for customers to receive their orders. This will involve analyzing the current order fulfillment process and identifying areas for improvement, such as streamlining production, optimizing shipping routes, and implementing a more efficient inventory management system.",Stanley Hudson,Enhance,low,medium,Ryan Howard,Meredith Palmer,Jo Bennett,Operations,2025-01-16,2025-05-16,alexandre.ops,5,Discovery
+Carbon Footprint Reduction,"Our company aims to reduce carbon footprint by implementing a smart grid system that integrates solar panels, wind turbines, and energy storage systems to provide a stable and efficient renewable energy supply to commercial and residential areas. This project will not only decrease our reliance on fossil fuels but also reduce energy costs for our customers. We will work with local authorities to ensure compliance with environmental regulations and partner with energy experts to optimize system performance.",Dwight Schrute,New Service,high,high,Kevin Malone,Meredith Palmer,Robert California,Digital Workplace,2025-01-17,2025-07-16,alexandre.finance,20,In Flight
+Claim Process Journey Map,"The goal of this project is to develop a comprehensive customer journey map that highlights the pain points experienced by policyholders during the claims process. The objective is to identify areas for improvement to enhance the customer experience and reduce the average claims resolution time. Key stakeholders include claims adjusters, policyholders, and underwriters. The project will involve analyzing customer feedback, claims data, and industry benchmarks to inform the journey map and recommendations for improvement.",Michael Scott,Enhance,medium,medium,Ryan Howard,Darryl Philbin,David Wallace,Finance,2025-02-06,2025-08-05,alexandre.finance,5,In Flight
+University Onboarding program,"The client is a prominent University that offers a range of undergraduate and postgraduate programs. To enhance student engagement and academic success, the University aims to implement a new student information system that integrates with existing student records and learning management systems. The system will enable students to track their academic progress, access course materials, and communicate with instructors in a seamless manner. The project objective is to increase student retention and satisfaction, improve academic performance, and reduce administrative burdens for the academic staff.",Stanley Hudson,New Build,low,medium_high,Oscar Martinez,Creed Bratton,Jo Bennett,Human Resources,2025-02-08,2025-06-08,alexandre.hr,15,In Flight
+Customer Support Optimisation,"The project aims to enhance the efficiency of the customer support service by creating a centralized knowledge base that captures key information and business process flows. The team must identify the most common issues experienced by customers and the current solutions provided by the support team. Once this information is gathered, the team will create a comprehensive list of stakeholders, including their roles and responsibilities. This will be the foundation for the design of the knowledge base.",Stanley Hudson,New Build,low,medium,Kevin Malone,Meredith Palmer,David Wallace,Customer Service,2025-02-21,2025-05-22,alexandre.csm,,In Flight
+Customer Experience Digital Platform,"Our company aims to develop a digital platform to enhance the customer experience for buying and selling second-hand electronics. The platform will include features such as product listing, price comparison, and customer feedback. Our target audience is environmentally conscious consumers who prefer to buy second-hand products. The platform will be integrated with popular social media channels to increase brand visibility and reach a wider audience. We plan to partner with local waste management organizations to promote sustainable practices and reduce electronic waste. Key stakeholders include product suppliers, customers, and waste management experts. Our goal is to reduce the average sale time of second-hand electronics by 30% and increase sales revenue by 25% within the first year.",Stanley Hudson,New Service,high,high,Kevin Malone,Meredith Palmer,Holly Flax,Digital Workplace,2025-04-01,2025-09-28,,2,Business Case
+Renewable Energy solution,"An energy storage system that utilizes advanced battery technology to optimize renewable energy output and mitigate intermittency of solar and wind power, ensuring a stable power supply to the grid and reducing carbon footprint in the hospitality sector.",Dwight Schrute,New Buy,high,high,Angela Martin,Meredith Palmer,Jan Levinson,Digital Workplace,2025-04-04,2025-07-03,,1,Business Case
+Insurance Claims Optimisation,"The insurance company needs to streamline the process of handling claims for customers who have suffered property damage due to natural disasters. The company aims to reduce the average processing time from 10 days to 3 days while maintaining a high level of customer satisfaction. Stakeholders involved include insurance agents, adjusters, and claims examiners. The journey map should facilitate seamless communication and efficient decision-making among these stakeholders.",Stanley Hudson,Enhance,low,medium,Oscar Martinez,Toby Flenderson,Holly Flax,Finance,2025-04-15,2025-07-14,,,Business Case
+Track and Trace programme,"The company aims to enhance its supply chain efficiency by automating the tracking and monitoring of shipments. This involves integrating data from various stakeholders, including carriers, warehouses, and delivery personnel, to provide real-time updates on shipment status and location. The project objective is to reduce delivery times, increase transparency, and improve customer satisfaction.",Pam Beesly,New Build,high,high,Oscar Martinez,Creed Bratton,David Wallace,Operations,2025-04-30,2026-03-31,,1,Business Case
+Retail Digital Transformation,"The objective of this project is to design and implement a digital transformation journey map for a large retail corporation, enabling them to improve customer engagement and drive sales through omnichannel experiences. The stakeholder list includes marketing, sales, and IT teams. The problem description reveals inefficiencies in the current supply chain process, and the project's primary objective is to enhance customer satisfaction through streamlined operations and data-driven decision making.",Jim Halpert,Enhance,high,medium_high,Kevin Malone,Meredith Palmer,Jan Levinson,Marketing,2025-05-05,2026-03-31,,2,Business Case
+Invest Management Platform,"The project aims to develop a digital platform for streamlined investment management and portfolio optimization, catering to high-net-worth individuals and institutions. The platform will integrate advanced data analytics and machine learning algorithms to provide personalized investment recommendations, risk assessments, and real-time portfolio performance tracking.",Michael Scott,New Service,high,medium_high,Angela Martin,Darryl Philbin,Jan Levinson,Finance,2025-05-30,2025-12-16,,1,Business Case
+Manufacturing Optimisation,"The proposed plan aims to increase the efficiency of the production line by reducing the time spent on quality control checks from 15 minutes to 5 minutes per product unit. Additionally, the new manufacturing process will involve the implementation of robotics to minimize human error and streamline the assembly process.",Dwight Schrute,Enhance,medium,medium,Kelly Kapoor,Toby Flenderson,Jo Bennett,Operations,2025-05-30,2026-03-01,,10,Business Case
+AI Research Platform,"The proposed development of the AI-powered research platform seeks to bridge the gap between theoretical models and practical applications in machine learning. By integrating cutting-edge algorithms with real-world data, the system aims to provide actionable insights for data scientists and researchers. This project will focus on optimizing the workflow and automating routine tasks, ultimately enhancing the productivity of the research team.",Pam Beesly,New Service,high,high,Kelly Kapoor,Toby Flenderson,David Wallace,AI COE,,,,1,New Request
+Customer Feedback Machine Learning Model,"The proposed system utilizes a combination of machine learning algorithms and natural language processing techniques to facilitate the analysis of customer feedback. By integrating sentiment analysis, topic modeling, and entity recognition, the system aims to provide a comprehensive understanding of customer sentiment and preferences.",Dwight Schrute,Enhance,high,high,Ryan Howard,Phyllis Vance,Holly Flax,Customer Service,,,,1,New Request
+Real Estate Machine Learning Model,"The goal of our project is to develop a machine learning model that can accurately predict house prices based on features such as the number of bedrooms, square footage, and location. We will collect data from various sources, preprocess it, and train a regression model to make predictions.",Michael Scott,New Build,high,medium_high,Ryan Howard,Phyllis Vance,Jan Levinson,Finance,,,,1,New Request
+Stock Market Chaos Theory,"Recent studies on the econophysics of complex financial systems have highlighted the potential benefits of incorporating chaos theory into predictive modeling of stock market fluctuations. By examining the fractal structure of stock price dynamics, researchers have been able to identify patterns that may be indicative of future market trends. However, the applicability of these findings to real-world investment strategies remains uncertain due to the complexity of market interactions and the presence of nonlinear feedback loops.",Michael Scott,Enhance,high,high,Oscar Martinez,Phyllis Vance,David Wallace,Finance,,,,1,New Request
+Sustainable Products Review,"The recent decline in sales can be attributed to the strategic shift in consumer behavior, driven by the increasing awareness of sustainable and eco-friendly products. This change in consumer preferences has resulted in a significant decrease in demand for our company's traditional products.",Dwight Schrute,Enhance,high,high,Ryan Howard,Toby Flenderson,Jan Levinson,Procurement,,,,1,New Request
+Social Media Sentiment Analysis,"The proposed AI-powered system utilizes a hybrid approach combining traditional machine learning algorithms with deep learning architectures to improve the accuracy of sentiment analysis in social media posts. By integrating various natural language processing techniques, the system can effectively capture nuances in human language and provide more accurate emotional intelligence.",Jim Halpert,New Buy,low,medium,Oscar Martinez,Creed Bratton,Robert California,Marketing,,,,,New Request
+Thermodynamics Engineer Novel,This experiment aims to investigate the feasibility of leveraging non-equilibrium thermodynamics to engineer novel materials with tailored mechanical properties by exploiting the relationships between entropy and free energy in nanoscale systems.,Dwight Schrute,New Service,high,medium_high,Kevin Malone,Phyllis Vance,Jan Levinson,Research and Development,,,,1,New Request
+High-End Flows Novel Exploration,"The proposed methodology for turbulence modeling in high-speed flows employs a novel combination of Direct Numerical Simulation (DNS) and Large Eddy Simulation (LES) techniques to capture the complex interactions between turbulence and mean flow. The approach involves a two-stage process: first, a DNS is performed to resolve the small-scale turbulence structures, and then the results are used to inform the LES simulation, which captures the larger-scale eddies. This hybrid approach enables the simulation of turbulent flows with high Reynolds numbers, thus providing valuable insights into the underlying physical mechanisms.",Jim Halpert,New Service,high,medium_high,Oscar Martinez,Creed Bratton,Jan Levinson,Research and Development,,,,1,New Request

ea4all/ea4all_store/ea4all_overview.txt

@@ -0,0 +1,36 @@
+- `Empower individuals with Knowledge`: understand and talk about Business and Technology strategy, IT landscape, Architectue Artefacts in a single click of button.
+- `Increase efficiency and productivity`: generate a documented architecture with diagram, model and descriptions. Accelerate Business Requirement identification and translation to Target Reference Architecture. Automated steps and reduced times for task execution.
+- `Improve agility`: plan, execute, review and iterate over EA inputs and outputs. Increase the ability to adapt, transform and execute at pace and scale in response to changes in strategy, threats and opportunities.
+- `Increase collaboration`: democratise architecture work and knowledge with anyone using natural language.
+
+Knowledge Context
+
+Synthetic datasets are used to exemplify the Agentic System capabilities.
+
+IT Landscape Question and Answering
+
+    - Application name
+        - Business fit: appropriate, inadequate, perfect
+        - Technical fit: adequate, insufficient, perfect
+        - Business_criticality: operational, medium, high, critical
+        - Roadmap: maintain, invest, divers
+        - Architect responsible
+        - Hosting: user device, on-premise, IaaS, SaaS
+        - Business capability
+        - Business domain
+        - Description  
+
+    
+Architecture Diagram Visual Question and Answering
+
+    - Architecture Visual Artefacts
+        - jpeg, png
+
+        **Disclaimer**
+                - Your data & image are not accessible or shared with anyone else nor used for training purpose.
+                - EA4ALL-VQA Agent should be used ONLY FOR Architecture Diagram images.
+                - This feature should NOT BE USED to process inappropriate content.
+
+Reference Architecture Generation
+
+    - Clock in/out Use-case

ea4all/ea4all_store/pmo_qna_mock.txt

@@ -0,0 +1,3 @@
+What architects are working on in flight projects?
+List all new projects without an architect.
+List all projects from the AI COE without an architect.

ea4all/ea4all_store/reference_architecture_dbr_assistant.txt

@@ -0,0 +1,9 @@
+Purpose of this document 
+
+The purpose of this document is to provide an overview of the project and specifically detail the business requirements for the project across the relevant business and market areas. 
+
+The requirements and solution will be agreed with the project sponsor (s) through formal review and sign off of this document. 
+Once signed off it will provide input to the subsequent design and development phases of the project.
+
+Why we need this project 
+I want an assistant to take notes during a workshop and translate that into a pseudo process and generate a visual representation that I can then refine in a focused session.

ea4all/ea4all_store/reference_architecture_dbr_demo.txt

@@ -0,0 +1,43 @@
+Purpose of this document 
+
+The purpose of this document is to provide an overview of the project and specifically detail the business requirements for the project across the relevant business and market areas. 
+
+The requirements and solution will be agreed with the project sponsor (s) through formal review and sign off of this document. 
+Once signed off it will provide input to the subsequent design and development phases of the project.
+
+Context 
+ (These areas can be taken from the Brief/ PID as appropriate)
+Background
+• Change in external scenario - more integrated supervisory organs;
+• Validity of the exception model adopted questioning (number of inquiries) 
+• Labor lawsuits average ticket is very high (number of lawsuits)
+  
+Why we need this project 
+To make it possible to control the schedule of work on employees that are legally required to. 
+
+Expected Business Outcome / Objective (Goal)    
+To implement the Electronic Timecard in all company business units to the public that are subject to the schedule of work and by that, reduce the number and impact of worktime related lawsuits
+
+Project Objectives
+Be compliance with current regulation regarding Timestamp with all employees with work schedule.
+
+Ref,Feature,Description,MoSCoW
+A,Input,Registration of ins/outs of employees  at the system,M
+B,Joiner,Registration of new employees considering the new system,M
+C,Workplace Change,Changes of a workplace of a given employee,M
+D,employee time,may it be from subject to worktime to noto r vice versa,M
+E,New Equipment,New equipment instalation on facilities,M
+F,Calendar change,Change of holydays of a given workplace,M
+G,New Worktime,Creation of new Time schedules for employees,M
+H,New balance rule,Creation of new Time balance rules for employees,M
+
+
+Actor Catalogue 
+
+Name, Description,Goals 
+Employees,Employee of company under time control,To register ins and outs
+Coordinator,Immediate superior of non-computer user employee,To register daily activities regarding Time management of non-computer user employees subject to them
+Immediate superior,Immediate superior of employee,To approve  daily activities regarding Time management of employees
+Manager,Employees first manager,To approve JMLs and monthly activities regarding Time management of employees
+Local Medical Service,Business unity Doctor,To include absence regarding sick leaves
+HRSS,Key users of Shared Services of Human Resources,To manage the back end of time system

ea4all/ea4all_store/strategic_principles.txt

@@ -0,0 +1,40 @@
+# Strategic Principles
+architecture_principles = """
+| Architecture Principle | Description |
+| --- | --- |
+| **Business Continuity** | The architecture must ensure that critical business functions can continue to operate during and after a disaster or unexpected downtime. |
+| **Interoperability** | Systems and data must be able to interact with each other, both within and across organizational boundaries. |
+| **Modularity** | The architecture should be composed of modular components that can be independently updated or replaced. |
+| **Scalability** | The architecture should be designed to handle increasing amounts of work in a graceful manner. |
+| **Secure by Design** | The architecture must protect information and systems from unauthorized access and provide confidentiality, integrity, and availability. |
+| **Simplicity** | The architecture should be as simple as possible, while still meeting business needs. Avoid unnecessary complexity. |
+| **Standardization** | Use industry standards where they exist and are appropriate for the business. |
+| **Sustainability** | The architecture should be sustainable and consider the environmental impact of IT decisions. |
+| **User-Centric** | The architecture should focus on the user experience, and be designed with the needs and behaviors of the user in mind.
+"""
+
+business_principles = """
+| Business Principle | Description |
+| --- | --- |
+| **Customer Focus** | The interests of the customer must be at the center of all decisions and operations. |
+| **Value Creation** | Every initiative and operation should aim to create value for the customers and the business. |
+| **Continuous Improvement** | The business should always strive for better ways to deliver value, through innovation and improvement. |
+| **Integrity** | The business should operate in an ethical and transparent manner. |
+| **Collaboration** | Working together across teams and departments is essential for delivering value. |
+| **Agility** | The business should be able to quickly respond to changes in the market or environment. |
+| **Sustainability** | Decisions should consider their long-term impact on the environment and society. |
+| **Accountability** | Every team and individual in the business should take responsibility for their actions and decisions. |
+| **Data-Driven Decision Making** | Decisions should be based on data and factual information.
+"""
+
+technology_principles = """
+| Technology Principle | Description |
+| --- | --- |
+| **Reliability** | Systems should be dependable and perform consistently under all conditions. |
+| **Maintainability** | Technology should be easy to update and improve over time. |
+| **Efficiency** | Systems and processes should be designed to minimize waste and maximize productivity. |
+| **User-Centric Design** | Technology should be designed with the end user in mind, ensuring it is easy to use and meets user needs. |
+| **Data Integrity** | Ensuring the accuracy and consistency of data over its entire lifecycle. |
+| **Sustainability** | Technology decisions should consider their impact on the environment. |
+| **Innovation** | Embracing new technologies and ideas to stay competitive and meet evolving business needs.
+"""

ea4all/main.py

@@ -0,0 +1,6 @@
+##version 2025-06-04
+#ea4all-gradio-agent-mcp-entry-point
+from ea4all.__main__ import main
+
+if __name__ == '__main__':
+    main()

ea4all/packages.txt

@@ -0,0 +1 @@
+graphviz

ea4all/src/__init__.py

@@ -0,0 +1,4 @@
+"""Shared utilities module."""
+
+#from ea4all.src.graph import super_graph
+#__all__ = ["super_graph"]

ea4all/src/ea4all_apm/configuration.py

@@ -0,0 +1,35 @@
+"""Define the configurable parameters for the APM agent."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Annotated, Literal
+
+import ea4all.src.ea4all_apm.prompts as prompts
+from ea4all.src.shared.configuration import BaseConfiguration
+
+@dataclass(kw_only=True)
+class AgentConfiguration(BaseConfiguration):
+    """The configuration for the agent."""
+
+    # prompts
+    router_system_prompt: str = field(
+        default=prompts.ROUTER_SYSTEM_PROMPT,
+        metadata={
+            "description": "The system prompt used for classifying user questions to route them to the correct node."
+        },
+    )
+
+    query_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="meta-llama/Llama-3.3-70B-Instruct",
+        metadata={
+            "description": "The language model used for processing and refining queries. Should be in the form: provider/model-name."
+        },
+    )
+
+    response_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="meta-llama/Llama-3.3-70B-Instruct",
+        metadata={
+            "description": "The language model used for generating responses. Should be in the form: provider/model-name."
+        },
+    )

ea4all/src/ea4all_apm/graph.py

@@ -0,0 +1,906 @@
+"""Main entrypoint for the conversational APM graph.
+
+This module defines the core structure and functionality of the conversational
+APM graph. It includes the main graph definition, state management,
+and key functions for processing & routing user queries, generating answer to
+Enterprise Architecture related user questions
+about an IT Landscape or Websearch.
+"""
+
+#CHANGELOG: 2025-06-08
+# Refactored to use tools.websearch (changes State, removed web_search)
+
+import os
+
+from langgraph.graph import END, StateGraph
+
+#core libraries
+from langchain_core.runnables import RunnableConfig
+from langchain_core.prompts.chat import ChatPromptTemplate
+from langchain_core.prompts import PromptTemplate, FewShotChatMessagePromptTemplate
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers.json import JsonOutputParser
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnableLambda
+from langchain_core.runnables import RunnablePassthrough, RunnableConfig
+from langchain_core.runnables import RunnableGenerator
+from langchain_core.documents import Document
+
+from langchain.load import dumps, loads
+from langchain.hub import pull
+
+from operator import itemgetter
+from typing import AsyncGenerator, AsyncIterator
+
+#compute amount of tokens used
+import tiktoken
+
+#import APMGraph packages
+from ea4all.src.ea4all_apm.configuration import AgentConfiguration
+from ea4all.src.ea4all_apm.state import InputState, OutputState, OverallState
+import ea4all.src.ea4all_apm.prompts as e4p
+from ea4all.src.shared.utils import (
+    load_mock_content, 
+    get_llm_client, 
+    get_history_gradio, 
+    extract_structured_output, 
+    extract_topic_from_business_input,
+    _join_paths,
+)
+from ea4all.src.shared import vectorstore
+from ea4all.src.tools.tools import (
+    websearch,
+)
+
+# This file contains sample APM QUESTIONS
+APM_MOCK_QNA = "apm_qna_mock.txt"
+
+async def retrieve_documents(
+    state: OverallState, *, config: RunnableConfig
+) -> dict[str, list[Document]]:
+    """Retrieve documents based on a given query.
+
+    This function uses a retriever to fetch relevant documents for a given query.
+
+    Args:
+        state (QueryState): The current state containing the query string.
+        config (RunnableConfig): Configuration with the retriever used to fetch documents.
+
+    Returns:
+        dict[str, list[Document]]: A dictionary with a 'documents' key containing the list of retrieved documents.
+    """
+    with vectorstore.make_retriever(config) as retriever:
+        response = await retriever.ainvoke(state.question, config)
+        return {"messages": response}
+
+async def apm_retriever(config: RunnableConfig):
+    with vectorstore.make_retriever(config) as retriever:
+        response = retriever
+
+    return response
+
+# Few Shot Examples
+few_shot_step_back_examples = [
+    {
+        "input": "Who can I talk to about innovation?",
+        "output": '{"datasource": "vectorstore, "topic":"who can I talk to"}"}',
+    },
+    {
+        "input": "Describe the finance landscape.",
+        "output": '{"datasource": "vectorstore", "topic:":"line of business landscape"}',
+    },
+    {
+        "input": "What applications support the marketing landscape?",
+        "output": '{"datasource": "vectorstore", "topic:":"line of business landscape"}',
+    },
+    {
+        "input": "List the simplification opportunities for the collaboration space.",
+        "output": '{"datasource": "vectorstore", "topic:":"line of business landscape"}',
+    },
+    {
+        "input": "What are the available patterns to deploy AI applications into AWS?",
+        "output": '{"datasource": "websearch", "topic:":"design patterns"}',
+    },
+    {
+        "input": "What is a Well-Architected Framework?",
+        "output": '{"datasource": "websearch", "topic:":"architecture framework"}',
+    },
+    {
+        "input": "What is a Cloud Assessment Framework?",
+        "output": '{"datasource": "websearch", "topic:":"cloud assessment framework"}',
+    },
+    {
+        "input": "What are the main architecture frameworks?",
+        "output": '{"datasource": "websearch", "topic:":"architecture framework"}',
+    },
+]
+
+# We now transform these to example messages
+few_shot_step_back_examples_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("human", "{input}"),
+        ("ai", "{output}"),
+    ]
+)
+
+few_shot_prompt = FewShotChatMessagePromptTemplate(
+    input_variables=["user_question"],
+    example_prompt=few_shot_step_back_examples_prompt,
+    examples=few_shot_step_back_examples,
+)
+
+## RAG from scratch: Query Translations functions
+def get_unique_union(documents: list[list]):
+    """ Unique union of retrieved docs """
+    # Flatten list of lists, and convert each Document to string
+    flattened_docs = [dumps(doc) for sublist in documents for doc in sublist]
+    # Get unique documents
+    unique_docs = list(set(flattened_docs))
+    # Return
+    return [loads(doc) for doc in unique_docs]
+
+def reciprocal_rank_fusion(results: list[list], k=60):
+    """ Reciprocal_rank_fusion that takes multiple lists of ranked documents 
+        and an optional parameter k used in the RRF formula """
+    
+    # Initialize a dictionary to hold fused scores for each unique document
+    fused_scores = {}
+
+    # Iterate through each list of ranked documents
+    for docs in results:
+        # Iterate through each document in the list, with its rank (position in the list)
+        for rank, doc in enumerate(docs):
+            # Convert the document to a string format to use as a key (assumes documents can be serialized to JSON)
+            doc_str = doc.metadata['source']
+            # If the document is not yet in the fused_scores dictionary, add it with an initial score of 0
+            if doc_str not in fused_scores:
+                fused_scores[doc_str] = [doc,0]
+            # Retrieve the current score of the document, if any
+            #previous_score = fused_scores[doc_str]
+            # Update the score of the document using the RRF formula: 1 / (rank + k)
+            fused_scores[doc_str][1] += 1 / (rank + k)
+
+    # Sort the documents based on their fused scores in descending order to get the final reranked results
+    reranked_results = [
+        doc[0]
+        for source, doc in sorted(fused_scores.items(), key=lambda x: x[0], reverse=True)
+    ]
+
+    # Return the reranked results as a list of tuples, each containing the document and its fused score
+    return reranked_results
+
+def format_qa_pair(question, answer):
+    """Format Q and A pair"""
+    
+    formatted_string = ""
+    formatted_string += f"Question: {question}\nAnswer: {answer}\n\n"
+    return formatted_string.strip()
+
+async def get_retrieval_chain(rag_input, ea4all_user, question, retriever, config: RunnableConfig):
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+    llm = get_llm_client(configuration.query_model, api_base_url=configuration.api_base_url) 
+ 
+    #retriever = retriever_faiss(db, ea4all_user) 
+    #CHANGE: Receive as parameter originer 
+    #retriever = await apm_retriever(config) #NEEDS retrofit to add user_login
+
+    if rag_input == 1: # Multi-query
+        ## RAG Query Transformation: Multi query 
+        prompt_perspectives = ChatPromptTemplate.from_template(e4p.multiquery_template)
+        generate_queries = (
+            prompt_perspectives 
+            | llm
+            | StrOutputParser() 
+            | (lambda x: x.split("\n"))
+        )
+        # Retrieve chain
+        retrieval_chain = generate_queries | retriever.map() | get_unique_union
+
+    elif rag_input == 2: # RAG Fusion
+        # Prompt
+        prompt_rag_fusion = ChatPromptTemplate.from_template(e4p.rag_fusion_questions_template)
+        generate_queries = (
+            prompt_rag_fusion 
+            | llm
+            | StrOutputParser() 
+            | (lambda x: x.split("\n"))
+        )
+        # Retrieval chain
+        retrieval_chain = generate_queries | retriever.map() | reciprocal_rank_fusion
+        
+    elif rag_input == 3: # Decomposition
+        # Build prompt
+        prompt_decomposition = ChatPromptTemplate.from_template(e4p.decomposition_template)
+        # Chain
+        generate_queries_decomposition = ( prompt_decomposition | llm | StrOutputParser() | (lambda x: x.split("\n")))
+
+        # Return new set of questions
+        questions = generate_queries_decomposition.invoke(
+            {"question": question},
+            {"tags": [os.environ['EA4ALL_ENV']], "metadata": {"ea4all_user": ea4all_user, "rag_input": rag_input}}
+        )
+        # Prompt: Answer recuservely 
+        decomposition_prompt = ChatPromptTemplate.from_template(e4p.decomposition_answer_recursevely_template)
+
+        # Answer each question and return final answer
+        answer = ""
+        q_a_pairs = ""
+        for q in questions:    
+            rag_chain = (
+                {"context": itemgetter("question") | retriever, 
+                "question": itemgetter("question"),
+                "q_a_pairs": itemgetter("q_a_pairs")} 
+                | decomposition_prompt
+                | llm
+                | StrOutputParser())
+
+            answer = rag_chain.invoke(
+                {"question":q,"q_a_pairs":q_a_pairs},
+                {"tags": [os.environ['EA4ALL_ENV']], "metadata": {"ea4all_user": ea4all_user, "rag_input": rag_input}}
+            )
+
+            q_a_pair = format_qa_pair(q,answer)
+            q_a_pairs = q_a_pairs + "\n---\n" + q_a_pair
+
+        return answer # Final response to user inquiry
+ 
+    elif rag_input == 4: # RAG Step-back
+
+        generate_queries_step_back = e4p.few_shot_step_back_prompt | llm | StrOutputParser()
+        
+        generate_queries_step_back.invoke(
+            {"standalone_question": lambda x: x["standalone_question"]},
+            {"tags": [os.environ['EA4ALL_ENV']], "metadata": {"ea4all_user": ea4all_user, "rag_input": rag_input}}
+        )
+
+        response_prompt = ChatPromptTemplate.from_template(e4p.step_back_response_prompt_template)
+
+        retrieval_chain = (
+            {
+                # Retrieve context using the normal question
+                "normal_context": RunnableLambda(lambda x: getattr(x, "standalone_question")) | retriever,
+                # Retrieve context using the step-back question
+                "step_back_context": generate_queries_step_back | retriever,
+                # Pass on the question
+                "standalone_question": lambda x: x["standalone_question"],
+            }
+            | response_prompt
+            | llm
+            | StrOutputParser()
+        )
+
+    elif rag_input == 5: # RAG HyDE
+        # Prompt
+        prompt_hyde = ChatPromptTemplate.from_template(e4p.hyde_template)
+        generate_docs_for_retrieval = (
+            prompt_hyde | 
+            llm | 
+            StrOutputParser()
+        )
+
+        retrieval_chain = generate_docs_for_retrieval | retriever 
+
+    else:
+        # Standard RAG approach - user query
+        retrieval_chain = itemgetter("standalone_question") | retriever
+    
+    return retrieval_chain
+
+#Get relevant asnwers to user query
+##get_relevant_documents "deprecated" - replaced by invoke : 2024-06-07
+async def get_relevant_answers(state: OverallState, query, config: RunnableConfig):
+
+    if query != "":
+        #retriever.vectorstore.index.ntotal
+        #retriever = retriever_faiss(user_ip)
+        #response = retriever.invoke({"standalone_question": query})
+        
+        response = await retrieve_documents(state, config=config)
+        return response
+    else:
+        return []
+
+#Return LLM answer to user inquriy
+def rag_llm(llm, chat_prompt, query, response):
+    answers = llm.invoke(
+        chat_prompt.format_prompt(
+            cdocs=response, query=query,
+        )
+    )
+
+    try:
+        return answers.content    
+    except AttributeError:
+        return answers
+    
+#Save user apm to disk
+def ea4all_serialize(apm_file, user_ip):
+    import pickle
+
+    # Specify the target filename
+    filename = _join_paths(AgentConfiguration.ea4all_store, f"apm_{user_ip}.pkl")
+    
+    # Serialize and save the binary data to a file
+    try:
+        with open(filename, 'wb') as file:
+            pickle.dump(apm_file, file)
+        return True
+    # Some code that might raise an exception
+    except Exception:
+        # Handle the exception
+        return False
+  
+#number of tokens consumed
+def num_tokens_from_string(string: str, encoding_name: str) -> int:
+    """Returns the number of tokens in a text string."""
+    encoding = tiktoken.get_encoding(encoding_name)
+    num_tokens = len(encoding.encode(string))
+    return num_tokens
+
+#retrieve relevant questions based on user interaction
+def get_relevant_questions():
+    relevant_questions = []
+    mock = load_mock_content(APM_MOCK_QNA)
+    for line in mock.splitlines(): relevant_questions += [line]
+
+    return relevant_questions
+
+#Rephrase the original user question based on system prompt to lead a better LLM answer
+def user_query_rephrasing(
+        state: OverallState, _prompt=None, *, config: RunnableConfig
+    ) -> dict[str,str]:
+
+    question = getattr(state,'question')
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+    # 'model = load_chat_model(configuration.query_model)
+    model = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    if _prompt:
+        rewrite_prompt = pull("learn-it-all-do-it-all/ea4all_user_question_rephrase")
+        inputs =  {"user_question": question} #, "ai_output": e4p.LLAMA31_PROMPT_FORMAT}
+    else:
+        rewrite_prompt = pull("learn-it-all-do-it-all/ea4all_question_rewriter")
+        inputs =  {"user_question": question, "target":"web search"}
+
+    rewrite_chain = rewrite_prompt | model | JsonOutputParser()
+
+    result = rewrite_chain.invoke(
+       input=inputs
+    )
+    
+    try:
+        question = result['rephrased']
+    except Exception:
+        question = state.question
+        
+    return {"question": question}
+
+# Post-processing
+def format_docs(docs):
+    return "\n".join(doc.page_content for doc in docs)
+
+def identify_task_category(
+    question,chat_memory,config: RunnableConfig
+):  
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    prompt = pull("learn-it-all-do-it-all/apm_task_router")
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    try:
+        # x=get_history_gradio(x) extract Human / AI
+        # fake gradio chat memory
+        x={"chat_memory":[]}
+        x['chat_memory'] = chat_memory
+        # extract human message only
+        memory=""
+        for human, ai in x['chat_memory']: memory += human + ";"
+
+        chain_one = prompt | llm | JsonOutputParser()
+        result = chain_one.invoke({"user_question": memory + question if x else question})
+
+        #parse response and pass on to next chain2/prompt2
+        response = extract_topic_from_business_input(result)
+
+        return response
+    except Exception:
+        return {'primary': 'General Inquiry'}
+
+def retrieval_grader(model):
+    prompt = PromptTemplate(
+        template="""<|begin_of_text|><|start_header_id|>system<|end_header_id|> You are a grader assessing relevance 
+        of a retrieved document to a user question. If the document contains keywords related to the user question, 
+        grade it as relevant. It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \n
+        Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question. \n
+        Provide the binary score as a JSON with a single key 'score' and no premable or explanation.
+        <|eot_id|><|start_header_id|>user<|end_header_id|>
+        Here is the retrieved document: \n\n {document} \n\n
+        Here is the user question: {question} \n <|eot_id|><|start_header_id|>assistant<|end_header_id|>
+        """,
+        input_variables=["user_question", "document"],
+    )
+
+    retrieval_grader = prompt | model | JsonOutputParser()
+
+    return retrieval_grader
+
+def hallucination_grader(model):
+    # Prompt
+    prompt = pull("learn-it-all-do-it-all/ea4all_apm_hallucination_grader")
+    hallucination_grader = prompt | model | JsonOutputParser()
+
+    return hallucination_grader
+
+def grade_answer(model):
+    # Prompt
+    prompt = PromptTemplate(
+        template="""<|begin_of_text|><|start_header_id|>system<|end_header_id|> You are a grader assistant and your task is to assess the answer relevance to address a user question.\n
+        Give a binary score 'yes' to indicate that the answer is relevant or 'no' otherwise.\n
+        Provide the binary score as a JSON with a keys 'score' and nothing else.\n
+        <|eot_id|><|start_header_id|>user<|end_header_id|> Here is the answer:
+        \n ------- \n
+        {generation}
+        \n ------- \n
+        Here is the question: {user_question} <|eot_id|><|start_header_id|>assistant<|end_header_id|>""",
+        input_variables=["generation", "user_question"],
+    )
+
+    answer_grader = prompt | model | JsonOutputParser()
+
+    return answer_grader
+
+async def grade_documents(state, config: RunnableConfig):
+    """
+    Determines whether the retrieved documents are relevant to the question
+    If any document is not relevant, we will set a flag to run web search
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Filtered out irrelevant documents and updated web_search state
+    """
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    print("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
+    question = state.question
+    documents = state.messages
+    source = state.source
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    # Score each doc
+    filtered_docs = []
+    for d in documents:
+        score = retrieval_grader(llm).ainvoke(
+            {"user_question": question, "document": d.page_content}
+        )
+        grade = getattr(score,"score", "no")
+        # Document relevant
+        if grade.lower() == "yes":
+            print("---GRADE: DOCUMENT RELEVANT---")
+            filtered_docs.append(d)
+        # Document not relevant
+        else:
+            print("---GRADE: DOCUMENT NOT RELEVANT---")
+            # We do not include the document in filtered_docs
+            # We set a flag to indicate that we want to run web search
+            #web_search = "Yes"
+            source = "websearch"
+    
+    return {"documents": filtered_docs, "question": question, "source": source}
+
+def decide_to_generate(state):
+    """
+    Determines whether to generate an answer, or add web search
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Binary decision for next node to call
+    """
+
+    print("---ASSESS GRADED DOCUMENTS---")
+    state.question
+    source = state.source
+    getattr(state,'documents')
+
+    if source == "websearch":
+        # All documents have been filtered check_relevance
+        # We will re-generate a new query
+        print(
+            "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, INCLUDE WEB SEARCH---"
+        )
+        return "websearch"
+    else:
+        # We have relevant documents, so generate answer
+        print("---DECISION: GENERATE---")
+        return "generate"
+
+def grade_generation_v_documents_and_question(
+    state:OverallState, config: RunnableConfig) -> str:
+    """
+    Determines whether the generation is grounded in the document and answers question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Decision for next node to call
+    """
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    question = getattr(state,'question')
+    documents = getattr(state,'messages')
+    generation = getattr(state,'generation')
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    if getattr(state,'source') == "websearch":
+        #print("---CHECK HALLUCINATIONS---")
+        hallucination_grader_instance =  hallucination_grader(llm)
+        #for output in hallucination_grader_instance.stream(
+        output = hallucination_grader_instance.invoke(
+            {"documents": documents, "generation": generation},
+            config={"tags":["stream_hallucination"]})
+            #yield(output)
+        grade = output["score"]
+        print("---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---") if grade=="yes" else exit
+    else:
+        grade = 'yes'
+
+    # Check hallucination
+    if grade == "yes":
+        #Check question-answering
+        print("---GRADE GENERATION vs QUESTION---")
+        grade_answer_instance =  grade_answer(llm)
+        #for output in grade_answer_instance.stream(
+        output = grade_answer_instance.invoke(
+            {"user_question": question, "generation": generation},
+            config={"tags":["stream_grade_answer"]})
+            #yield(output)
+        grade = output["score"]
+        if grade == "yes":
+            print("---DECISION: GENERATION ADDRESSES QUESTION---")
+            return "useful"
+        else:
+            print("---DECISION: GENERATION DOES NOT ADDRESS QUESTION---")
+            return "not useful"
+    else:
+        print("---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---")
+        return "not supported"
+
+async def apm_query_router(
+    state: OverallState, config: RunnableConfig
+) -> str:
+    
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    routing_prompt = pull('learn-it-all-do-it-all/ea4all-apm-user-question-routing')
+
+    #update prompt with few-shot-examples
+    updated_prompt = routing_prompt.from_messages([routing_prompt.messages[0], few_shot_prompt, routing_prompt.messages[1], routing_prompt.messages[2]])
+    # Apply partial variables to the created template
+    updated_prompt = updated_prompt.partial(
+        metadata=e4p.TEMPLATE_APM_QNA_ROUTING,
+    )
+
+    model = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    route = updated_prompt | model
+
+    ##Rephrase user question to lead bettern LLM response
+    #PROMPT as context NOT WORKING AS EXPECTED 2024-09-23
+    user_query = user_query_rephrasing(state=state, _prompt=updated_prompt, config=config)['question']
+
+    response = await route.ainvoke({"user_question": user_query})
+
+    extracted = extract_structured_output(response.content)
+    if extracted is not None:
+        datasource = extracted.get('datasource', 'vectorstore')
+    else:
+        datasource = 'vectorstore'
+    
+    return datasource
+
+async def retrieve(
+    state: OverallState, config: RunnableConfig
+):
+    """
+    Retrieve documents
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, documents, that contains retrieved documents
+    """
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    #print("---RETRIEVE---")
+    question = getattr(state,'question')
+
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    with vectorstore.make_retriever(config) as _retriever:
+        retriever = _retriever
+
+    # First we add a step to load memory from gr.ChatInterface.history_chat
+    # This adds a "memory" key to the input object
+    loaded_memory = RunnablePassthrough.assign(
+        chat_history = RunnableLambda(get_history_gradio) | itemgetter("history"))
+    
+    # Now we calculate the standalone question <= Original Question + ChatHistory
+    standalone_question = {
+        "standalone_question": {
+            "chat_history": lambda x: str(x["chat_history"]),
+            "user_question": lambda x: x['user_question']
+        }
+        | e4p.CONDENSE_QUESTION_PROMPT
+        | llm
+        | StrOutputParser()
+    }
+
+   # Retrieval
+    rag_input = int(getattr(state,'rag'))
+    retrieval_chain = await get_retrieval_chain(rag_input,"ea4all_agent",question,retriever, config=config)
+   
+    retrieved_documents = {
+        "cdocs": retrieval_chain,
+        "user_question": itemgetter("standalone_question")
+    }
+
+    # And now we put it all together!
+    final_chain = loaded_memory | standalone_question | retrieved_documents
+    
+    documents = await final_chain.ainvoke({"user_question": question, "chat_memory":[]})
+
+    return {"messages": format_docs(documents['cdocs']), "question": question, "rag":getattr(state,'rag')}
+
+### Edges ###
+def route_to_node(state:OverallState):
+    
+    if state.source == "websearch":
+        #print("---ROUTE QUESTION TO WEB SEARCH---")
+        return "websearch"
+    elif state.source == "vectorstore":
+        #print("---ROUTE QUESTION TO RAG---")
+        return "vectorstore"
+
+async def route_question(
+    state: OverallState, config: RunnableConfig
+) -> dict[str, str]:
+    """
+    Route question to web search or RAG.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Next node to call
+    """
+
+    #print("---ROUTE QUESTION---")
+    source = await apm_query_router(state, config)
+    
+    return {"source":source}
+    
+async def stream_generation(
+    state: OverallState, config: RunnableConfig
+) -> AsyncGenerator[str, None]:
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url,streaming=configuration.streaming)
+
+    documents = None
+    question = None
+    source = None
+    chat_memory = None
+    async for s in state:
+        documents = getattr(s,"messages")
+        question = getattr(s,"question")
+        source = getattr(s,"source")
+        chat_memory = getattr(s,"chat_memory")
+
+    # Prompt Web Search generation
+    if source == "websearch":
+        prompt = PromptTemplate(
+            template="""<|begin_of_text|><|start_header_id|>system<|end_header_id|> You are an enterprise architect assistant for question-answering tasks.
+            Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. 
+            Keep the answer concise <|eot_id|><|start_header_id|>user<|end_header_id|>
+            Question: {user_question} 
+            Context: {cdocs} 
+            Answer: <|eot_id|><|start_header_id|>assistant<|end_header_id|>""",
+            input_variables=["user_question", "cdocs"],
+        ) 
+    else:
+        # Now we construct the inputs for the final prompt
+        # identify primary, second category
+        tc = identify_task_category(question,chat_memory,config)
+        prompt = e4p.ea4ll_prompt_selector(tc['primary'])
+                
+    rag_chain = prompt | llm | StrOutputParser()
+
+    async for output in rag_chain.astream({"cdocs": documents, "user_question": question}):
+        yield(output)
+    
+async def generate(
+        state: OverallState, config: RunnableConfig
+    ) -> dict[str, str]:
+    """
+    Generate answer
+
+    Args:
+        state (dict): The current graph state
+        config (RunnableConfig): Configuration with the model used for query analysis.
+
+    Returns:
+        state (dict): New key added to state, generation, that contains LLM generation
+    """
+    #print("---GENERATE---")
+
+    #documents = getattr(state,'messages')[-1].content #documents
+    source = getattr(state,'source') 
+    #question = getattr(state,'question')
+
+    ##Triggered by hallucination_grade? 2025-02-21 - NOT USER being edged to END atm
+    #2025-02-21: it's being triggered by super_graph supervisor as well - need to review as calling web_search twice
+    #if getattr(state,'generation') is None:
+    #    if getattr(state,'web_search') == "Yes":
+    #        await websearch(state, config)
+    #    else:
+    #        state.rag = "1"
+    #        await retrieve(state, config)
+
+    # Generate answer
+    tags = ["websearch_stream"] if source == "websearch" else ["apm_stream"]
+    gen = RunnableGenerator(stream_generation).with_config(tags=tags)
+    generation=""
+    async for message in gen.astream(state):
+        generation = ''.join([generation,message])
+   
+    #return {"messages": documents.content, "question": question, "generation": generation, "web_search": web_search}
+    return {"generation": generation}
+
+#ea4all-qna-agent-conversational-with-memory
+async def apm_agentic_qna(
+    state:OverallState, config: RunnableConfig):
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    question = getattr(state,'question')
+    chat_memory = getattr(state,'chat_memory')
+
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    retriever = await apm_retriever(config)
+
+    # First we add a step to load memory from gr.ChatInterface.history_chat
+    # This adds a "memory" key to the input object
+    loaded_memory = RunnablePassthrough.assign(
+        chat_history = itemgetter("chat_memory"))
+    
+    # Now we calculate the standalone question <= Original Question + ChatHistory
+    standalone_question = {
+        "standalone_question": {
+            "chat_history": lambda x: str(x["chat_history"]),
+            "user_question": lambda x: x["user_question"]
+        }
+        | e4p.CONDENSE_QUESTION_PROMPT
+        | llm
+        | StrOutputParser()
+    }
+
+    # Start with Hyde
+    prompt_hyde = ChatPromptTemplate.from_template(e4p.hyde_template)
+    generate_docs_for_retrieval = (
+        prompt_hyde | 
+        llm | 
+        StrOutputParser()
+    )
+    retrieval_chain = generate_docs_for_retrieval | retriever 
+
+    retrieved_documents = {
+        "cdocs": retrieval_chain,
+        "query": itemgetter("standalone_question")
+    }
+
+    # And now we put it all together!
+    final_chain = loaded_memory | standalone_question | retrieved_documents
+    
+    documents = await final_chain.ainvoke({"user_question": question, "chat_memory":chat_memory})
+
+    #return {"documents": format_docs(documents['cdocs']), "question": question, "rag":5, "generation": None}
+    return {"messages": format_docs(documents['cdocs']), "rag":5}
+
+async def final(state: OverallState):
+    return {"safety_status": state}
+
+async def choose_next(state: OverallState):
+    if state.safety_status is not None and len(state.safety_status) > 0 and state.safety_status[0] == 'no':
+        return "exit"
+    else:
+        return "route"
+
+class SafetyCheck:
+    def apm_safety_check(self,state: OverallState, config: RunnableConfig):
+
+        configuration = AgentConfiguration.from_runnable_config(config)
+        question = state.question
+
+        safety_prompt = pull('learn-it-all-do-it-all/ea4all_apm_safety_check')
+
+        llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+        route = safety_prompt | llm | JsonOutputParser()
+    
+        response = route.invoke({"user_question": question})
+
+        try:
+            score = response['score']
+            explain = response['response']
+        except ValueError:
+            score = 'no'
+            explain = 'I cannot answer your question at moment!' 
+        
+        return {"safety_status": [score, explain, question]}
+
+    def __init__(self):
+        self._safety_run = self.apm_safety_check
+
+    def __call__(self, state: OverallState, config: RunnableConfig) -> dict[str, list]:
+        try:
+            response = getattr(self, '_safety_run')(state, config)
+            return {"safety_status": [response['safety_status'][0], "", state.question]}
+        except Exception as e:
+            return {"safety_status": ['no', e, state.question]}
+
+##BUILD APM Graph
+# Build graph
+workflow = StateGraph(OverallState, input=InputState, output=OutputState, config_schema=AgentConfiguration)
+
+# Define the nodes
+workflow.add_node("safety_check",SafetyCheck())
+workflow.add_node("route_question", route_question) # route to vectorstore or websearch
+workflow.add_node("retrieve", apm_agentic_qna)  # retrieve
+workflow.add_node("websearch", websearch)  # web search
+workflow.add_node("generate", generate)  # generate web search based answer
+workflow.add_node("final", final)
+
+workflow.set_entry_point("safety_check")
+workflow.add_conditional_edges(
+    "safety_check",
+    choose_next,
+    {
+        "exit": "final",
+        "route": "route_question"
+    }
+)
+workflow.add_conditional_edges(
+    "route_question",
+    route_to_node,
+    {
+        "websearch": "websearch",
+        "vectorstore": "retrieve",
+    },
+)
+workflow.add_edge("retrieve", "generate")
+workflow.add_edge("websearch", "generate")
+workflow.add_conditional_edges( #2025-02-27: Conditional edges expect sync function only
+    "generate",
+    grade_generation_v_documents_and_question,
+    {
+        "not supported": "route_question",
+        "useful": END,
+        "not useful": END, ##2025-02-21: need to review THIS to try again and respond to user with a better answer
+    },
+)
+workflow.add_edge("final", END)
+
+# Compile
+apm_graph = workflow.compile()
+apm_graph.name = "APMGraph"

ea4all/src/ea4all_apm/prompts.py

@@ -0,0 +1,292 @@
+"""Default prompts and support functions."""
+
+#prompt libraries
+from langchain_core.prompts.chat import (ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate,)
+from langchain_core.prompts import PromptTemplate, FewShotChatMessagePromptTemplate
+from langchain_core.prompts import format_document
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.chains.prompt_selector import ConditionalPromptSelector
+
+from langchain_core.output_parsers.json import JsonOutputParser
+
+##return a prompt-template class with informed user inquiry
+def ea4all_prompt(query):
+    prompt_template = PromptTemplate(
+        input_variables=["query", "answer"],
+        template=TEMPLATE_QUERY_ANSWER)
+
+    prompt = prompt_template.format(
+        query=query,
+        answer="")
+
+    return prompt
+
+##return a chat-prompt-template class from the informed template
+def ea4all_chat_prompt(template):
+    system_message_prompt = SystemMessagePromptTemplate.from_template(template)
+    human_template = "{user_question}"
+    human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
+
+    ea4all_prompt = ChatPromptTemplate.from_messages(
+        messages=[
+            system_message_prompt, 
+##            MessagesPlaceholder(variable_name="history"),
+            human_message_prompt],
+    )
+    ea4all_prompt.output_parser=JsonOutputParser()
+    
+    return ea4all_prompt
+
+##select best prompt based on user inquiry's category
+def ea4ll_prompt_selector(category):
+    QUESTION_PROMPT_SELECTOR = ConditionalPromptSelector(
+        default_prompt = ea4all_chat_prompt(GENERAL_TEMPLATE),
+        conditionals=[
+            (lambda category: True if category == "Strategy" else False, ea4all_chat_prompt(STRATEGY_TEMPLATE)),
+            (lambda category: True if category == "Application" else False, ea4all_chat_prompt(APPLICATION_TEMPLATE)),
+            (lambda category: True if category == "Recommendation" else False, ea4all_chat_prompt(RECOMMENDATION_TEMPLATE)),
+            (lambda category: True if category not in ("Strategy","Application", "Recommendation") else False, ea4all_chat_prompt(GENERAL_TEMPLATE))
+        ]
+    )
+ 
+    prompt = QUESTION_PROMPT_SELECTOR.get_prompt(category)
+
+    return(prompt)
+
+
+##Template-basic instruction + context
+TEMPLATE_CONTEXT = """You are a helpful Enterprise Architect with knowledge on enterprises IT landscapes.
+Use only the context delimited by trible backticks to answer questions. Return the answer formatted as a text paragraph.
+If you don't know the answer return I could not find the information.
+Don't make up the response.
+Context: ```{cdocs}```
+Help answer: ""
+"""
+
+##Template-basic instruction + question + answer
+TEMPLATE_QUERY_ANSWER = """You are Enterprise Architect highly knowledgable on IT landscape. \
+Answer the question that is delimited by triple backticks into a style that is bullet list. \
+If the question cannot be answered using the information provided answer with "I don't know". \
+
+Always say "thanks for asking!" at the end of the answer. 
+
+Question: ```{user_question}```
+Answer: {answer}
+"""
+
+TEMPLATE_APM_QNA_ROUTING = """application portfolio assessment, application/IT landscape rationalisation, simplification or optimisation, business capability assessment, line of business landscape, who can I talk to, assistance from architecture team."""
+
+##Template-break-into-simpler-tasks
+#https://platform.openai.com/docs/guides/prompt-engineering/strategy-split-complex-tasks-into-simpler-subtasks
+TEMPLATE_HEADER = """You are a helpful enterprise architect assistant. """
+TEMPLATE_HEADER += """Your goal is to provide accurate and detailed responses to user inquiry. """
+TEMPLATE_HEADER += """You have access to a vast amount of enterprise architecture knowledge, """
+TEMPLATE_HEADER += """and you can understand and generate language fluently. """
+TEMPLATE_HEADER += """You can assist with a wide range of architectural topics, including but not limited to """
+TEMPLATE_HEADER += """business, application, data and technology architectures. """
+TEMPLATE_HEADER += """You should always strive to promote a positive and respectful conversation. 
+"""
+
+TEMPLATE_TASKS = ""
+TEMPLATE_TASKS += """You will be provided with a user inquiry. """ 
+TEMPLATE_TASKS += """Classify the inquiry into primary category and secondary category. """
+TEMPLATE_TASKS += """Primary categories: Strategy, Application, Recommendation or General Inquiry. """
+TEMPLATE_TASKS += """Strategy secondary categories: 
+- Architecture and Technology Strategy
+- Vision
+- Architecture Principles
+"""
+TEMPLATE_TASKS += """Application secondary categories:
+- Meet business and technical need
+- Business criticality
+- Roadmap
+- Business Capability 
+- Hosting 
+"""
+TEMPLATE_TASKS += """Recommendation secondary categories:
+- Application rationalisation
+- Landscape simplification
+- Reuse existent invested application
+- Business capability with overlapping applications
+- Opportunities and innovation
+"""
+TEMPLATE_TASKS += """General inquiry:
+- Speak to an architect
+"""
+TEMPLATE_TASKS += """You may also revise the original inquiry if you think that revising \
+it will ultimately lead to a better response from the language model """
+TEMPLATE_TASKS += """Provide your output in JSON format with the keys: primary, secondary, question.
+"""
+
+#Template-break-into-specific-prompt-by-category
+strategy_template = """You will be provided with inquiry about architecture strategy. 
+Follow these steps to answer user inquiry:
+STEP 1 - Using only the context delimited by triple backticks.
+STEP 2 - Look at application with roadmap to invest.
+STEP 3 - Extract the information that is only relevant to help answer the user inquiry
+"""
+
+application_template = """You will be provided with an inquiry about application architecture. 
+Follow these steps to answer user inquiry:
+STEP 1 - Using only the context delimited by triple backticks.
+STEP 2 - Extract the information that is only relevant to help answer the user inquiry
+"""
+
+recommendation_template = """You will be provided with enterprise architecture inquiry that needs a recommendation. 
+Follow these steps to answer user inquiry:
+STEP 1 - Use only the context delimited by triple backticks.
+STEP 2 - Look at applications with low business or technical fit
+STEP 3 - Look at application with roadmap diffent to invest
+STEP 4 - Look at applicatins hosted on premise
+STEP 5 - Look at Business capability with overlapping applications
+"""
+
+general_template = """You will provided with a general inquiry about enterprise architecture IT landscape.
+Follow these steps to answer user queries:
+STEP 1 - use only the context delimited by triple backticks
+STEP 2 - Extract the information that is only relevant to help answer the user inquiry
+"""
+
+default_template = """
+FINAL STEP - Do not make up or guess ANY extra information. \
+Ask follow-up question to the user if you need further clarification to understand and answer their inquiry. \
+After a follow-up question if you still don't know the answer or don't find specific information needed to answer the user inquiry \
+return I could not find the information. \
+Ensure that the response contain all relevant context needed to interpret them -
+in other words don't extract small snippets that are missing important context.
+Format the output as top-like string formatted with the most appropriate style to make it clear, concise and user-friendly for a chatbot response.
+Here is the question: {user_question}
+Here is the context: ```{cdocs}```
+"""
+
+STRATEGY_TEMPLATE = TEMPLATE_HEADER + strategy_template + default_template
+APPLICATION_TEMPLATE = TEMPLATE_HEADER + application_template + default_template
+RECOMMENDATION_TEMPLATE = TEMPLATE_HEADER + recommendation_template + default_template
+GENERAL_TEMPLATE = TEMPLATE_HEADER + general_template + default_template
+
+
+###############################################
+##COLLECTION of prompts for conversation memory
+###############################################
+
+_template = """Given the following conversation and a follow up question,\
+rephrase the follow up question to be a standalone question, in its original language.\
+Chat History:
+{chat_history}
+Follow Up Input: {user_question}
+Standalone question:"""
+
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template="{page_content}")
+
+
+def _combine_documents(
+    docs, document_prompt=DEFAULT_DOCUMENT_PROMPT, document_separator="\n\n"
+    ):
+    doc_strings = [format_document(doc, document_prompt) for doc in docs]
+    
+    return document_separator.join(doc_strings)
+
+
+##################################################
+##COLLECTION of prompts - RAG query transformation
+##################################################
+## Multi Query
+# Prompt
+multiquery_template = """You are an AI Enterprise Architect language model assistant. Your task is to generate five 
+different versions of the given user question to retrieve relevant documents from a vector 
+database. By generating multiple perspectives on the user question, your goal is to help
+the user overcome some of the limitations of the distance-based similarity search. 
+Provide these alternative questions separated by newlines. Original question: {standalone_question}"""
+
+decomposition_template = """You are a helpful enterprise architect assistant that generates multiple sub-questions related to an input question. \n
+The goal is to break down the input into a set of sub-problems / sub-questions that can be answers in isolation. \n
+Generate multiple search queries related to: {user_question} \n
+Output (3 queries):"""
+
+decomposition_answer_recursevely_template = """
+Here is the question you need to answer:
+
+\n --- \n {question} \n --- \n
+
+Here is any available background question + answer pairs:
+
+\n --- \n {q_a_pairs} \n --- \n
+
+Here is additional context relevant to the question: 
+
+\n --- \n {context} \n --- \n
+
+Use the above context and any background question + answer pairs to answer the question: \n {user_question}
+"""
+
+rag_fusion_questions_template = """You are a helpful enterprise architect assistant that generates multiple search queries based on a single input query. \n
+Generate multiple search queries related to: {standalone_question} \n
+Output (4 queries):"""
+
+# Few Shot Examples
+few_shot_step_back_examples = [
+    {
+        "input": "Could the members of The Police perform lawful arrests?",
+        "output": "what can the members of The Police do?",
+    },
+    {
+        "input": "Jan Sindel was born in what country?",
+        "output": "what is Jan Sindel personal history?",
+    },
+]
+# We now transform these to example messages
+few_shot_step_back_examples_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("human", "{input}"),
+        ("ai", "{output}"),
+    ]
+)
+few_shot_prompt = FewShotChatMessagePromptTemplate(
+    input_variables=["standalone_question"],
+    example_prompt=few_shot_step_back_examples_prompt,
+    examples=few_shot_step_back_examples,
+)
+few_shot_step_back_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """You are an expert at enterprise architecture world knowledge. Your task is to step back and paraphrase a question to a more generic step-back question, which is easier to answer. Here are a few examples:""",
+        ),
+        # Few shot examples
+        few_shot_prompt,
+        # New question
+        ("user", "{standalone_question}"),
+    ]
+)
+# Response prompt 
+step_back_response_prompt_template = """You are an expert of enterprise architecture world knowledge. I am going to ask you a question. Your response should be comprehensive and not contradicted with the following context if they are relevant. Otherwise, ignore them if they are not relevant.
+
+# {normal_context}
+# {step_back_context}
+
+# Original Question: {standalone_question}
+"""
+
+# HyDE document generation
+hyde_template = """Please write an architecture scientific passage to answer the question
+Question: {standalone_question}
+Passage:"""
+
+# Retrieval APM Graph - TO BE REVIEWED
+ROUTER_SYSTEM_PROMPT = """You are a LangChain Developer advocate. Your job is help people using LangChain answer any issues they are running into.
+
+A user will come to you with an inquiry. Your first job is to classify what type of inquiry it is. The types of inquiries you should classify it as are:
+
+## `more-info`
+Classify a user inquiry as this if you need more information before you will be able to help them. Examples include:
+- The user complains about an error but doesn't provide the error
+- The user says something isn't working but doesn't explain why/how it's not working
+
+## `langchain`
+Classify a user inquiry as this if it can be answered by looking up information related to LangChain open source package. The LangChain open source package \
+is a python library for working with LLMs. It integrates with various LLMs, databases and APIs.
+
+## `general`
+Classify a user inquiry as this if it is just a general question"""
+

ea4all/src/ea4all_apm/state.py

@@ -0,0 +1,59 @@
+"""State management for the APM graph.
+
+This module defines the state structures used in the APM graph. It includes
+definitions for agent state, input state, and router classification schema.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Literal, List, Tuple
+from typing_extensions import TypedDict
+
+class Router(TypedDict):
+    """Classify a user query."""
+    logic: str
+    datasource: Optional[Literal["vectorstore", "websearch"]]
+
+# Optional, the InputState is a restricted version of the State that is used to
+# define a narrower interface to the outside world vs. what is maintained
+# internally.
+@dataclass(kw_only=True)
+class InputState:
+    """Represents the input state for the agent.
+
+    This class defines the structure of the input state, which includes
+    the messages exchanged between the user and the agent. It serves as
+    a restricted version of the full State, providing a narrower interface
+    to the outside world compared to what is maintained internally.
+    """
+
+    """Attributes:
+        question: user question
+    """
+    question: str
+
+@dataclass(kw_only=True)
+class OutputState:
+    """Represents the output schema for the APM agent."""
+    question: str
+    messages: Optional[List[str]] = None
+    generation: Optional[str] = None
+    source: Optional[str] = None
+    """Answer to user's Architecture IT Landscape question about ."""
+
+@dataclass(kw_only=True)
+class OverallState(InputState, OutputState):
+    """State of the APM graph / agent."""
+    
+    """
+    safety_status: user question's safeguarding status, justification, rephrased question
+    router: classification of the user's query
+    source: RAG or websearch
+    retrieved: list of documents retrieved by the retriever
+    rag: last RAG approach used
+    chat_memory: user chat memory
+    """
+    safety_status: Optional[Tuple[str, str, str]] = None
+    router: Optional[Router] = None
+    rag: Optional[str] = None
+    chat_memory: Optional[str] = None
+    retrieved: Optional[List[str]] = None

ea4all/src/ea4all_gra/configuration.py

@@ -0,0 +1,46 @@
+"""Define the configurable parameters for the TOGAF agent."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Annotated
+
+from ea4all.src.shared.configuration import BaseConfiguration
+
+@dataclass(kw_only=True)
+class AgentConfiguration(BaseConfiguration):
+    """The configuration for the agent."""
+
+    supervisor_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="gpt-4o-mini",
+        metadata={
+            "description": "The language model used for supervisor agents. Should be in the form: provider/model-name."
+        },
+    )
+    togaf_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="meta-llama/Llama-3.3-70B-Instruct",
+        metadata={
+            "description": "The language model used for processing and refining queries. Should be in the form: provider/model-name."
+        },
+    )
+
+    recursion_limit: Annotated[int, {"__template_metadata__": {"kind": "integer"}}] = field(
+        default=10,
+        metadata={
+            "description": "The maximum number of times the agent can recursively call itself."
+        },
+    )
+
+    dbr_mock: Annotated[str, {"__template_metadata__": {"kind": "dataset"}}] = field(
+        default="dbr.txt",
+        metadata={
+            "description": "The EA4ALL Togal Business Requirement mock content."
+        },
+    )
+
+    ea4all_ask_human: Annotated[str, {"__template_metadata__": {"kind": "integration"}}] = field(
+        default="Frontend",
+        metadata={
+            "description": "Trigger EA4ALL ask human input via interruption or receive from external frontend."
+        },
+    )

ea4all/src/ea4all_gra/data.py

@@ -0,0 +1,131 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+"""
+This module defines the data models used in the EA4ALL TOGAF project.
+The data models include:
+- Capability: Represents a business capability.
+- BusinessCapability: Represents a list of required business capabilities.
+- Requirement: Represents a business requirement.
+- ListRequirement: Represents a list of identified business requirements.
+- Objective: Represents a business objective.
+- ListObjective: Represents a list of business objectives.
+- UseCase: Represents a use case describing user interactions with the system.
+- UserJourney: Represents a list of user journeys.
+- StakeholderMap: Represents a business stakeholder.
+- StakeholderList: Represents a list of business stakeholders.
+- IdentifiedApp: Represents an identified application.
+- LandscapeAsIs: Represents a list of applications to address a business query.
+- CapabilityAsIs: Represents the support status of a business capability.
+- CapabilityGap: Represents a list of capability support statuses.
+- GradeAnswer: Represents a binary score for relevance check on retrieved applications.
+- GradeHallucinations: Represents a binary score for hallucination present in generation answer.
+- GradeDocuments: Represents a binary score for relevance check on retrieved applications.
+- Principles: Represents the business, architecture, and technology principles.
+- GradeBusinessQueryAnswer: Represents a binary score for quality check on business query.
+"""
+
+
+class Capability(BaseModel):
+    """Business capability"""
+    capability: str = Field(description="Business capability name.")
+
+class BusinessCapability(BaseModel):
+    """List of required business capabilities."""
+    capabilities: Optional[List[Capability]]
+
+class Requirement(BaseModel):
+    """Business requirement."""
+    category: str = Field(description="Business requirement should be functional or non-functional")
+    requirement: str = Field(description="Business requirement description.")
+
+class ListRequirement(BaseModel):
+    """List of identified business requirements."""
+    requirements: Optional[List[Requirement]]
+
+class Objective(BaseModel):
+    """Business Objective"""
+    objective: str = Field(title=None, description="Business objective.")
+
+class ListObjective(BaseModel):
+    """List of business objectives."""
+    objectives: Optional[List[Objective]]
+
+class UseCase(BaseModel):
+    """Use case describing who (actor,user,persona) does what (interaction) with the system, for what purpose (goal), without dealing with system internals."""
+    persona: str = Field(description="User, actor or personna who interacts with the system.")
+    step: str = Field(description="Action executed by user.")
+    goal: str = Field(description="Purpose, goal of a step executed by user.")
+
+class UserJourney(BaseModel):
+    """List of user journey."""
+    userjourney: Optional[List[UseCase]]
+
+class StakeholderMap(BaseModel):
+    """Business stakeholder."""
+    stakeholder: str = Field(description="Stakeholder name.")
+    role: str = Field(description="Stakeholder role.")
+    concern: str = Field(description="Stakeholder concern.")
+
+class StakeholderList(BaseModel):
+    """List of business stakeholders."""
+    stakeholders: Optional[List[StakeholderMap]]
+                                            
+#Task-2
+class IdentifiedApp(BaseModel):
+    """Identified application"""
+    application: str = Field(description="Application name")
+    description: str = Field(description="Application description")
+    capability: list = Field(description="Business capabilities supported")
+    businessFit: str = Field(description="how well application support current business need")
+    technicalFit: str = Field(description="application alignment with technology strategy")
+    roadmap: str = Field(description="application portfolio strategy")
+
+class LandscapeAsIs(BaseModel):
+    """List of applications to address a business query."""
+    identified_asis: Optional[List[IdentifiedApp]]
+
+class CapabilityAsIs(BaseModel):
+    """Business capability support"""
+    capability: str = Field(description="business capability definition")
+    support: bool = Field(description="capability support status")
+
+class CapabilityGap(BaseModel):
+    """List of capabilities support status"""
+    capability_status: Optional[List[CapabilityAsIs]]
+
+class GradeAnswer(BaseModel):
+    """Binary score for relevance check on retrieved applications."""
+
+    binary_score: str = Field(...,
+        description="Relevance of retrieved applications to the business query, 'yes' or 'no'"
+    )
+
+class GradeHallucinations(BaseModel):
+    """Binary score for hallucination present in generation answer."""
+
+    binary_score: bool = Field(
+        description="Answer is grounded in the facts, 'yes' or 'no'"
+    )
+
+class GradeDocuments(BaseModel):
+    """Binary score for relevance check on retrieved applications."""
+
+    binary_score: str = Field(
+        description="Applications support the business capability, 'yes' or 'no'"
+    )
+
+#Task-3
+class Principles(BaseModel):
+    """Describe the business, archirecture and technology principles"""
+    architecture: list = Field(description="Name and description of an architecture principle")
+    business: list = Field(description="Name and description of a business principle")
+    technology: list = Field(description="Name and description of a technology principle")
+
+#Togaf-Agentic-Workflow
+class GradeBusinessQueryAnswer(BaseModel):
+    """Binary score for quality check on business query."""
+
+    binary_score: str = Field(
+        description="Business Query is well-described, 'yes' or 'no'"
+    )

ea4all/src/ea4all_gra/graph.py

@@ -0,0 +1,410 @@
+"""
+This module contains the implementation of a Togaf reference architecture graph.
+The graph represents a workflow for managing a conversation between team members
+in the context of Togaf, a framework for enterprise architecture development.
+
+The graph is defined using the StateGraph class from the langgraph library.
+It consists of several nodes, each representing a specific task or action in the workflow.
+The nodes are connected by edges, which control the flow of logic through the program.
+
+The main entry point of the graph is the "ask_human" node, which prompts the user to provide
+a business requirement document/file name. The input is then passed to the "enter_graph" node,
+which initializes the state of the graph with the provided input.
+
+The graph then proceeds to the "query_grader" node, which evaluates the quality of the business query.
+Based on the evaluation, the graph branches to different nodes, such as "assess_query", "assess_asis",
+and "generate_tobe", each representing a different task in the Togaf workflow.
+
+The "togaf_supervisor" node acts as a router, determining the next role to act based on the conversation
+and instructions. It uses an LLM (Learned Language Model) model to make the decision.
+
+The graph continues to execute the tasks until it reaches the "return" node, which generates a response
+to be returned to the user.
+
+The graph is compiled and saved as a Togaf_reference_architecture_graph object, which can be executed
+to run the workflow.
+
+The module also includes helper functions and utility classes used by the graph, as well as import statements
+for required libraries and modules.
+"""
+
+"""Changelog: 20250609
+- Refactored State classes to OverallState, InputState, OutputState
+- Task-1, Task-2, Task-3 State classes changed to TypedDicts
+- Review what's best content to provide Retrieve with requirements or intent
+"""
+
+
+#core libraries
+from langchain_core.runnables import RunnableConfig
+from langchain_core.prompts.chat import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import (
+    AIMessage,
+    SystemMessage,
+    HumanMessage,
+)
+from langchain_core.output_parsers import (
+    PydanticOutputParser, 
+    JsonOutputKeyToolsParser
+)
+from langgraph.graph import (
+    END, 
+    StateGraph,
+)
+from langgraph.types import Command, interrupt
+from langgraph.checkpoint.memory import MemorySaver
+
+from langchain import hub
+
+import functools
+
+from typing import List, Union, Dict
+from typing_extensions import Literal
+
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration
+from ea4all.src.ea4all_gra.state import OverallState, InputState, OutputState
+from ea4all.src.ea4all_gra.data import (
+    GradeBusinessQueryAnswer
+)
+
+from ea4all.src.shared.utils import (
+    get_llm_client,
+    clean_and_load_json,
+    extract_response_from_backticks,
+    load_mock_content,
+)
+from ea4all.src.shared.prompts import LLAMA31_PROMPT_FORMAT
+
+from ea4all.src.ea4all_gra.togaf_task1.graph import task1_graph
+from ea4all.src.ea4all_gra.togaf_task2.graph import task2_graph
+from ea4all.src.ea4all_gra.togaf_task3.graph import task3_graph
+
+from ea4all.src.ea4all_gra.utils import (
+    AsyncInterruptHandler
+)
+
+#CAPTURE business requirement asking for USER input & call togad_agentic workflow
+async def _get_user_input():
+
+    interrupt_handler = AsyncInterruptHandler()
+    result = await interrupt_handler.handle_interrupt()
+
+    return {"user_feedback": result}
+
+async def togaf_ask_human(state: OverallState, config: RunnableConfig):
+    # Check user_input method 
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    if "interrupt" in (AgentConfiguration.ea4all_ask_human, configuration.ea4all_ask_human):
+        print("--- TOGAF Blueprint Team --- User input requested")
+        response = interrupt(
+            {
+                "task": state.get('business_query'),
+                "content": "Please provide your business requirement in the form of document/file name or past the content:",
+                "optional": False
+            },
+        )
+
+        print(f"--- TOGAF AGENTIC team ---  got an answer and processing user input: {response}") 
+
+        business_query = load_mock_content(response['user_feedback'])
+    else:
+        business_query = state.get('business_query')
+
+    return Command(update={
+        "business_query": business_query,
+        }
+    )
+
+#DEFINE Helper functions
+def create_team_supervisor(
+        state: OverallState,
+        config:RunnableConfig):
+    members = ["AssessBusinessQuery", "AssessLandscape", "GenerateToBe"] #NEEDS REFACTORING
+
+    """An LLM-based router."""
+    options = ["FINISH"] + members
+    function_def = {
+        "name": "route",
+        "description": "Select the next role.",
+        "parameters": {
+            "title": "routeSchema",
+            "type": "object",
+            "properties": {
+                "next": {
+                    "type": "string",
+                    "title": "Next",
+                    "anyOf": [
+                        {"enum": options},
+                    ],
+                },
+            },
+            "required": ["next"],
+        },
+    }
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(
+        configuration.supervisor_model, 
+        api_base_url="",
+    )
+
+    system_prompt = " ".join([
+        'You are a supervisor tasked with managing a conversation between the',
+        'following team members: {team_members}. Respond with the worker to act next in sequence.',
+        'Each worker will perform a task and respond with their results and status.',
+        'After last worker is finished,respond with FINISH.']
+    )
+
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+            (
+                "system",
+                "Based on the above conversation and instructions who should act next."
+                "Or should we FINISH?. Select one of: {options}.",
+            ),
+        ]
+    ).partial(options=str(options),team_members=", ".join(members))
+    
+    return (
+        prompt
+        | model.bind_tools(tools=[function_def], tool_choice="route")
+        | JsonOutputKeyToolsParser(key_name='route', first_tool_only=True)
+    )
+
+# The following functions interoperate between the top level graph state
+# and the state of the sub-graph
+# this makes it so that the states of each graph don't get intermixed
+def task1_enter_chain(state:OverallState, members: List[str]) -> dict:
+    results = {
+        "messages": [AIMessage(content=str(state))],
+        "team_members": ", ".join(members),
+        "business_query": state.get('business_query'),
+        "next": state.get('next'),
+    }
+    return results
+
+def task2_enter_chain(state:OverallState, members: List[str]):
+    results = {
+        "messages": [AIMessage(content=str(state))],
+        "team_members": ", ".join(members),
+        "business_query": state.get('business_query'),
+        "intent": state.get('intent'),
+        "stakeholder": state.get('stakeholder'),
+        "biz_capability": state.get('biz_capability'),
+        "requirement": state.get('requirement'),
+        "userjourney": state.get('userjourney'),
+        "next": state.get('next')
+    }
+    return results
+
+def task3_enter_chain(state:OverallState, members: List[str]):
+    results = {
+        "messages": [AIMessage(content=str(state))],
+        "team_members": ", ".join(members),
+        "business_query": state.get('business_query'),
+        "intent": state.get('intent'),
+        "stakeholder": state.get('stakeholder'),
+        "biz_capability": state.get('biz_capability'),
+        "requirement": state.get('requirement'),
+        "userjourney": state.get('userjourney'),
+        "landscape_asis": state.get('landscape_asis'),
+        "identified_asis": state.get('identified_asis'),
+        "landscape_gap": state.get('landscape_gap'),
+        "next": state.get('next'),
+    }
+    return results
+
+def get_last_message(state: OverallState) -> dict:
+    results = {}
+    #results['messages'] = [state.get('messages')[-1].content]
+    results['next'] = state.get('next')
+    if state.get('business_query'):
+        results['business_query'] = state.get('business_query')
+    if state.get('principles'):
+        results['principles'] = state.get('principles')
+    if state.get('intent'):
+        results['intent'] = state.get('intent')
+    if state.get('stakeholder'):
+        results['stakeholder'] = state.get('stakeholder')
+    if state.get('biz_capability'):
+        results['biz_capability'] = state.get('biz_capability')
+    if state.get('requirement'):
+        results['requirement'] = state.get('requirement')
+    if state.get('userjourney'):
+        results['userjourney'] = state.get('userjourney')
+    if state.get('landscape_asis'):
+        results['landscape_asis'] = state.get('landscape_asis')
+    if state.get('identified_asis'):
+        results['identified_asis'] = state.get('identified_asis')
+    if state.get('landscape_gap'):
+        results['landscape_gap'] = state.get('landscape_gap')
+    if state.get('vision_target'):
+        results['vision_target'] = state.get('vision_target')
+    if state.get('architecture_runway'):
+        results['architecture_runway'] = state.get('architecture_runway')
+
+    return results
+
+def join_graph(state: OverallState) -> dict:
+    results = {}
+    results['messages'] = [state.get('business_query')[-1]]
+    results['next'] = state.get('next')
+    if state.get('business_query'):
+        results['business_query'] = state.get('business_query')
+    if state.get('principles'):
+        results['principles'] = state.get('principles')
+    if state.get('intent'):
+        results['intent'] = state.get('intent')
+    if state.get('stakeholder'):
+        results['stakeholder'] = state.get('stakeholder')
+    if state.get('biz_capability'):
+        results['biz_capability'] = state.get('biz_capability')
+    if state.get('requirement'):
+        results['requirement'] = state.get('requirement')
+    if state.get('userjourney'):
+        results['userjourney'] = state.get('userjourney')
+    if state.get('landscape_asis'):
+        results['landscape_asis'] = state.get('landscape_asis')
+    if state.get('identified_asis'):
+        results['identified_asis'] = state.get('identified_asis')
+    if state.get('landscape_gap'):
+        results['landscape_gap'] = state.get('identified_asis')
+    if state.get('vision_target'):
+        results['vision_target'] = state.get('vision_target')
+    if state.get('architecture_runway'):
+        results['architecture_runway'] = state.get('architecture_runway')
+
+    return results
+
+##Refactored to use Command instead of conditional_edge
+async def business_query_grader(state:OverallState, config:RunnableConfig) -> Command[Literal["assess_query", "return"]]:
+    print(f"--- TOGAF AGENTIC team ---  safety/quality review of the user requirement: {state.get('business_query')}") 
+    business_query = state.get('business_query')
+   
+    #if len(business_query) < 50:
+    #    return Command(
+    #        # state update
+    #        update={"query_status": False},
+    #        # control flow
+    #        goto="return",
+    #        )   
+ 
+    # Prompt
+    grader_prompt = hub.pull('learn-it-all-do-it-all/ea4all_business_query_grader')
+
+    # Set up a parser: 
+    #parser = PydanticOutputParser(pydantic_object=GradeBusinessQueryAnswer) 
+    #grader_prompt = grader_prompt.partial(
+    #    format_instructions=parser.get_format_instructions(),
+#        ai_output = LLAMA31_PROMPT_FORMAT,
+    #)
+ 
+    # Get any user-provided configs - LLM model in use
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
+
+    grader = grader_prompt | model
+
+    response = await grader.ainvoke(
+        {"business_query": state.get('business_query')}
+    )
+
+    binary_score = clean_and_load_json(extract_response_from_backticks(response.content))['binary_score']
+
+    messages = [
+        HumanMessage(content=state.get('business_query')),
+    ]
+    
+    if binary_score == "yes":
+        return Command(
+            # state update
+            update={"query_status": True, "messages": messages},
+            # control flow
+            goto="assess_query",
+            )
+    else:
+        return Command(
+            # state update
+            update={"query_status": False},
+            # control flow
+            goto="return",
+            )   
+
+def return_2user(state:OverallState):
+    message = '{"binary_score":"no"}'
+
+    return {
+        "messages": [AIMessage(content=str(message), name="return")],
+        "next": "end",
+    }
+
+async def enter_graph(state:dict, config: RunnableConfig) -> dict:
+
+    print(f"--- Entered TOGAF AGENTIC team to --- {state.get('business_query')}") #state.get('business_query')[-1].content
+    #if isinstance(state, dict):
+    #    user_feedback = state.get('user_feedback') if state.get('user_feedback') else state['messages'][-1].content
+    #else:
+    #    user_feedback = state.get('user_feedback', state['messages'][-1].content)
+    
+    #busines_query = load_mock_content(state.get('user_feedback')),
+
+    business_query = state['business_query'][-1]['content']
+
+    return {"business_query": business_query}
+
+## TOGAF Orchestrator Graph
+task1_business_query_chain = (
+    functools.partial(task1_enter_chain, members=list(task1_graph.nodes)) 
+    | task1_graph
+)
+
+task2_assess_asis_chain = (
+    functools.partial(task2_enter_chain, members=list(task2_graph.nodes))
+    | task2_graph
+)
+
+task3_vision_target_chain = (
+    functools.partial(task3_enter_chain, members=list(task3_graph.nodes))
+    | task3_graph
+)
+
+# Define the graph.
+workflow = StateGraph(OverallState, input=InputState, output=OutputState, config_schema=AgentConfiguration)
+# First add the nodes, which will do the work
+workflow.add_node("enter_graph", enter_graph)
+workflow.add_node("ask_human", togaf_ask_human)
+workflow.add_node("query_grader", business_query_grader)
+workflow.add_node("assess_query", get_last_message | task1_business_query_chain | join_graph)
+workflow.add_node("assess_asis", get_last_message | task2_assess_asis_chain | join_graph)
+workflow.add_node("generate_tobe", get_last_message | task3_vision_target_chain | join_graph)
+workflow.add_node("return", return_2user)
+
+# Define the graph connections, which controls how the logic
+# propagates through the program
+#workflow.add_conditional_edges(
+#    "togaf_supervisor",
+#    lambda x: x["next"],
+#    {
+#        "AssessBusinessQuery": "assess_query",
+#        "AssessLandscape": "assess_asis",
+#        "GenerateToBe": "generate_tobe",
+#        "FINISH": END,
+#    },
+#)
+
+workflow.add_edge("enter_graph", "ask_human")
+workflow.add_edge("ask_human", "query_grader")
+workflow.add_edge("assess_query", "assess_asis")
+workflow.add_edge("assess_asis", "generate_tobe")
+workflow.add_edge("generate_tobe", END)
+workflow.add_edge("return", END)
+
+workflow.set_entry_point("enter_graph")
+
+#memory = MemorySaver()
+togaf_graph = workflow.compile() #checkpointer=memory)
+togaf_graph.name = "Togaf_reference_architecture_graph"

ea4all/src/ea4all_gra/state.py

@@ -0,0 +1,85 @@
+from pydantic import Field
+from typing_extensions import (
+    Annotated,
+    TypedDict,
+    List
+)
+import operator
+from typing import (
+    Optional,
+)
+from dataclasses import dataclass, field
+from typing import Optional
+
+from ea4all.src.ea4all_gra.data import (
+    ListRequirement, 
+    ListObjective, 
+    UserJourney, 
+    StakeholderList, 
+    BusinessCapability, 
+    LandscapeAsIs, 
+    CapabilityGap, 
+    Principles
+)
+
+# Optional, the InputState is a restricted version of the State that is used to
+# define a narrower interface to the outside world vs. what is maintained
+# internally.
+@dataclass(kw_only=True)
+class InputState(TypedDict):
+    """Represents the input state for the agent.
+
+    This class defines the structure of the input state, which includes
+    the messages exchanged between the user and the agent. It serves as
+    a restricted version of the full State, providing a narrower interface
+    to the outside world compared to what is maintained internally.
+    """
+
+    """Attributes:
+        business_query: a business requirement is the starting point of the TOGAF process
+    """
+    #business_query: Optional[Annotated[List[str], Field(
+    #    description="A business requirement is the starting point of the TOGAF process."), operator.add]] 
+    business_query: str
+
+@dataclass(kw_only=True)
+class OutputState(TypedDict):
+    """Represents te output state for the agent."""
+    vision_target: Optional[str]
+    architecture_runway: Optional[str]
+
+@dataclass(kw_only=True)
+class OverallState(InputState, OutputState):
+    """Represents the state of a Togaf system."""
+
+    """
+    Attributes:
+    - user_feedback: used to capture additional information needed from the user by the graph
+    - business_query: a business requirement is the starting point of the TOGAF process
+    - query_status (Optional[bool]): Indicates the status of the query. Default value is False.
+    - messages (Optional[Annotated[list[AnyMessage], add_messages]]): A list of messages associated with the state.
+    - stakeholder (Optional[StakeholderList]): Represents the list of stakeholders.
+    - principles (Optional[Principles]): Represents the principles of the Togaf system.
+    - requirement (Optional[ListRequirement]): Represents the list of requirements.
+    - intent (Optional[ListObjective]): Represents the list of objectives.
+    - userjourney (Optional[UserJourney]): Represents the user journey of the Togaf system.
+    - biz_capability (Optional[BusinessCapability]): Represents the business capability of the Togaf system.
+    - landscape_asis (Optional[List[str]]): Represents the list of landscape as-is.
+    - identified_asis (Optional[LandscapeAsIs]): Represents the identified landscape as-is.
+    - landscape_gap (Optional[CapabilityGap]): Represents the capability gap of the landscape.
+    - vision_target (Optional[str]): Represents the vision target of the Togaf system.
+    - architecture_runway (Optional[str]): Represents the architecture runway of the Togaf system.
+    - next (Optional[str]): Represents the next step in the Togaf system.
+    """
+
+    query_status: Optional[bool]
+    stakeholder: Optional[StakeholderList]
+    principles: Optional[Principles]
+    requirement: Optional[ListRequirement]
+    intent: Optional[ListObjective]
+    userjourney: Optional[UserJourney]
+    biz_capability: Optional[BusinessCapability]
+    landscape_asis: Optional[List[str]]
+    identified_asis: Optional[LandscapeAsIs]
+    landscape_gap: Optional[CapabilityGap]
+    next: Optional[str]

ea4all/src/ea4all_gra/togaf_task1/graph.py

@@ -0,0 +1,125 @@
+#core libraries
+from langchain_core.runnables import RunnableConfig
+from langchain_core.messages import (
+    AIMessage
+)
+
+from langgraph.graph import (
+    END, 
+    StateGraph,
+)
+
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration
+from ea4all.src.ea4all_gra.data import (
+    ListRequirement,
+    ListObjective,
+    BusinessCapability,
+    StakeholderList,
+    UserJourney,
+)
+from ea4all.src.shared.utils import (
+    get_llm_client,
+    extract_detailed_business_requirements,
+)
+from ea4all.src.shared.prompts import LLAMA31_PROMPT_FORMAT
+
+from ea4all.src.ea4all_gra.togaf_task1.state import Task1State
+
+#EXECUTE STEP-1: Identify Business Requirements, Objectives, Capabilities, Stakeholders and Journey Agent 
+def assess_business_query(state: Task1State, config: RunnableConfig):
+    """Identified business requirements, goals, use cases, user journey, stakeholder and business capability from a given business query."""
+    #DEFINE agent template & prompt
+    #BROKE-DOWN BusinessInput into individual extractions: LLAMA-3 CONTEXT WINDOW limitation
+    #REMOVED parser from the chain: LLAMA-3 returning text + ```BusinessInput```
+    ##Parser back to chain 2024-10-13
+    #Setting streaming=True makes the model produces wrong output
+    query = state.get("business_query")
+
+    # Get any user-provided configs - LLM model in use
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
+
+    values = {"business_input": query}
+    final_response=[]
+
+    ##EXTRACT BUSINESS REQUIREMENT
+    response = extract_detailed_business_requirements(model, ListRequirement, "business requirement", values)
+    business_reqs = ""
+    try:
+        for item in response.requirements:
+            business_reqs += ':'.join([item.category, item.requirement.lower()]) + ";"
+        final_response += [response.requirements]
+    except Exception as e:
+        print(f"Houston, we a {e} thorny problem!")
+
+    ##EXTRACT BUSINESS OBJECTIVE
+    response = extract_detailed_business_requirements(model, ListObjective, "business objective", values)
+    business_goal=[]
+    try:
+        for item in response.objectives:
+            business_goal.append(item.objective)
+        final_response += [response.objectives]
+    except Exception as e:
+        print(f"Houston, we a {e} thorny problem!")
+
+
+    ##EXTRACT BUSINESS CAPABILITY
+    response = extract_detailed_business_requirements(model, BusinessCapability, "business capabilities", values)
+    business_capabilities=[]
+    try:
+        for item in response.capabilities:
+            business_capabilities.append(item.capability)
+        final_response += [response.capabilities]
+    except Exception as e:
+        print(f"Houston, we a {e} thorny problem!")
+
+
+    ##EXTRACT STAKEHOLDER
+    response = extract_detailed_business_requirements(model, StakeholderList, "business stakeholder", values)
+    business_stakeholder = ""
+    try:
+        for item in response.stakeholders:
+            business_stakeholder += ' '.join([item.stakeholder,item.role.lower(), item.concern]) + "."
+        final_response += [response.stakeholders]
+    except Exception as e:
+        print(f"Houston, we a {e} thorny problem!")
+
+
+    ##EXTRACT BUSINESS USER JOURNEY
+    response = extract_detailed_business_requirements(model, UserJourney, "user journey", values)
+    user_journey = ""
+    try:
+        for item in response.userjourney:
+            user_journey += ':'.join([item.persona,item.step.lower()]) + ","
+        final_response += [response.userjourney]
+    except Exception as e:
+        print(f"Houston, we a {e} thorny problem!")
+
+    name = state.get("next")
+
+    return {
+        "messages": [AIMessage(content=str(final_response), name=name)],
+        "requirement": business_reqs,
+        "intent": business_goal,
+        "stakeholder": business_stakeholder,
+        "userjourney": user_journey,
+        "biz_capability": str(business_capabilities)
+    }
+
+# Build graphs task1
+## TASK-1 Graph
+task1_builder = StateGraph(Task1State)
+
+# Define the nodes
+task1_builder.add_node("AssessBusinessQuery", assess_business_query)  # assess business input
+
+# Build graph
+task1_builder.add_edge("AssessBusinessQuery", END)
+task1_builder.set_entry_point("AssessBusinessQuery")
+
+# Set FINISH node end-point
+task1_builder.set_finish_point('AssessBusinessQuery')
+
+# Compile
+task1_graph = task1_builder.compile()
+task1_graph.name = "togaf_assess_business_query_graph"

ea4all/src/ea4all_gra/togaf_task1/state.py

@@ -0,0 +1,53 @@
+from pydantic import Field
+from typing_extensions import (
+    Annotated
+)
+import operator
+from typing import (
+    Optional,
+    Annotated, 
+    Sequence,
+    List
+)
+from dataclasses import dataclass
+from typing import Optional
+
+from langchain_core.messages import (
+    BaseMessage,
+)
+
+from ea4all.src.ea4all_gra.data import (
+    ListRequirement, 
+    ListObjective, 
+    UserJourney, 
+    StakeholderList, 
+    BusinessCapability, 
+)
+
+from ea4all.src.ea4all_gra.state import InputState
+
+# Task-1 Graph State
+@dataclass(kw_only=True)
+class Task1State(InputState):
+    """
+    Represents the BusinessOutput state of our graph.
+
+    Attributes:
+        message: a message is added after each team member finishes
+        team_members: the team members are tracked so they are aware of the others' skill-sets
+        next: used to route work. The supervisor calls a function that will update this every time it makes a decision
+        requirement: list of business requirements
+        intent: business objective, goal
+        userjourney: list of user journeys
+        stakeholder: list of stakeholder and their concerns
+        capability: list of business capabilities to deliver intent and requirements
+    """
+
+    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    team_members: Optional[List[str]]
+    requirement: Optional[ListRequirement]
+    intent: Optional[ListObjective]
+    userjourney: Optional[UserJourney]
+    stakeholder: Optional[StakeholderList]
+    biz_capability: Optional[BusinessCapability]
+    next: Optional[str]

ea4all/src/ea4all_gra/togaf_task2/graph.py

@@ -0,0 +1,457 @@
+import ast
+
+#core libraries
+from langchain_core.runnables import RunnableConfig, RunnableSerializable
+
+from langchain_core.messages import (
+    AIMessage,
+)
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.prompts.chat import ChatPromptTemplate
+
+from langchain import hub
+
+from langgraph.graph import (
+    END, 
+    StateGraph,
+)
+
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration
+from ea4all.src.ea4all_gra.data import (
+    CapabilityGap,
+    GradeAnswer,
+    GradeDocuments,  
+    LandscapeAsIs,  
+)
+
+from ea4all.src.shared.utils import (
+    get_llm_client,
+    extract_structured_output,
+    extract_topic_from_business_input,
+    set_max_new_tokens,
+    get_predicted_num_tokens_from_prompt,
+)
+
+from ea4all.src.shared.prompts import (
+    LLAMA31_CHAT_PROMPT_FORMAT,
+    LLAMA31_PROMPT_FORMAT,
+)
+
+from ea4all.src.shared import vectorstore
+
+from ea4all.src.ea4all_gra.togaf_task2.state import Task2State
+
+from ea4all.src.ea4all_apm.graph import get_retrieval_chain
+from ea4all.src.ea4all_apm import configuration as apm_config
+
+from ea4all.src.ea4all_gra.state import OverallState
+
+# Retrieval Grader score whether retrieved IT Landscape  address business query
+def retrieval_grader(model):
+    # LLM with function call
+    structured_llm_grader = model.with_structured_output(GradeDocuments)
+
+    #Prompt
+    system = """You are an enterprise architect grader assessing relevance of applications to address a business query.
+        It does not need to be a stringent test. The objective is to filter out erroneous retrievals.
+        If the application contains any keyword or semantic meaning related to the business query, grade it as relevant.
+        Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question."""
+
+    grade_prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system),
+            ("ai", "Retrieved applications: \n\n {landscape_asis} \n\n Business Query: {business_query}"),
+        ]
+    )
+
+    grader = grade_prompt | structured_llm_grader
+
+    return grader
+
+# Business Capability needs vs landscap asis gap analysis
+def gap_grader(model):
+   
+    gap_prompt = hub.pull("learn-it-all-do-it-all/ea4all_togaf_capability_gap")
+
+    # Set up a parser: 
+    parser = PydanticOutputParser(pydantic_object=CapabilityGap) 
+    gap_prompt = gap_prompt.partial(
+        format_instructions=parser.get_format_instructions(),
+    )
+
+    capability_gap_grader = gap_prompt | model | parser
+
+    return capability_gap_grader
+
+## Question Re-writer
+def question_rewriter(model):
+    # Rerwriter Prompt
+    rewrite_prompt = hub.pull("learn-it-all-do-it-all/ea4all_question_rewriter")
+    rewrite_prompt = rewrite_prompt.partial(ai_output=LLAMA31_CHAT_PROMPT_FORMAT)
+
+    rewriter = rewrite_prompt | model
+
+    return rewriter
+
+##Answer Grade: score whether RAG + LLM answer address business query
+def answer_grader():
+    # Prompt
+    answer_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_answer_grade')
+
+    # Set up a parser: 
+    parser = PydanticOutputParser(pydantic_object=GradeAnswer) 
+    answer_prompt = answer_prompt.partial(
+        format_instructions=parser.get_format_instructions(),
+        ai_output = LLAMA31_PROMPT_FORMAT
+    )
+
+    return answer_prompt
+
+## Hallucination Grader score whether there is any hallucination with between RAG and LLM answers
+def hallucination_grader(asis, identified):
+    # Prompt": REVISED TO WORK WIHT LLAMA-3 - issue w/ multi-word app
+    #changes on prompting e.g. role, rules and restrictions, explicit instructions, change from word to application(s)
+    #changed to one-by-one assessment using single text search
+    grader_false = []
+    for d in identified:
+        if d.lower() not in asis.lower():
+            grader_false.append(d)
+
+    return grader_false
+
+##Action-1 RAG retrieval - Assess-AsIs-Landscape
+async def retrieve(state:Task2State, config: RunnableConfig):
+    """
+    Retrieve applications
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, applications, that contains retrieved identified applications
+    """
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    print("---RETRIEVE---")
+    business_query = state['business_query']
+
+    if not state.get( 'landscape_asis'):
+        intent=""
+        if state['messages']:
+            intent = ','.join(ast.literal_eval(str(state['messages'][-1].content))['intent']).lower().replace("'", "")
+
+        business_query=f"""What existent applications can be re-used {intent}?"""
+
+    # Retrieval
+    rag_input = 5
+    #faiss_index = set_faiss_index(config)
+    with vectorstore.make_retriever(config) as _retriever:
+        retriever = _retriever
+
+    retrieval = await get_retrieval_chain(rag_input,"ea4all_agent",business_query,retriever, config)
+    
+    landscape_asis = await retrieval.ainvoke(
+        {"standalone_question": business_query},
+        config={"recursion_limit":configuration.ea4all_recursion_limit})
+
+    name = state['next']
+
+    ## return Document page_content
+    content = ';'.join(asis.page_content.strip() for asis in landscape_asis)
+    return {
+        "messages": [AIMessage(content=content, name=name)],
+        "landscape_asis": landscape_asis, 
+        "business_query": business_query
+    }
+
+##Action-2 Grade retrieval against business query, filter out not relevant applications
+def grade_landscape_asis(state:Task2State, config: RunnableConfig):
+    """
+    Determines whether an application is relevant to address a business query.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Updates landscape_asis key with only filtered relevant applications
+    """
+
+    print("---CHECK DOCUMENT RELEVANCE TO BUSINESS QUERY---")
+    business_query = state.get('business_query')
+    landscape_asis = state.get('landscape_asis')
+
+    # Score each doc
+    filtered_docs = []
+    if landscape_asis is not None:
+        for d in landscape_asis:
+            ##Pick relevant Metadata
+            application = d.metadata['source']
+            capability = d.metadata['capability']
+            description = d.metadata['description']  
+            business_fit = d.metadata['business fit']
+            roadmap = d.metadata['roadmap']
+            asis = f"Application:{application}; Capability:{capability}; Description:{description};Business fit: {business_fit}; Roadmap: {roadmap};"
+
+            filtered_docs.append(asis)
+                    
+    return {
+        #"messages": [AIMessage(content=str(filtered_docs), name=name)],
+        "business_query": business_query,
+        "landscape_asis": landscape_asis, 
+        "identified_asis": filtered_docs
+    }
+
+##Action-3 Is there relevant applications? Yes, generate, otherwise transform_query
+def decide_to_generate(state:Task2State, config: RunnableConfig):
+    """
+    Determines whether to generate an answer, or re-generate a question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Binary decision for next node to call
+    """
+
+    print("---ASSESS GRADED APPLICATIONS---")
+    filtered_applications = state['identified_asis']
+
+    if not filtered_applications:
+        # All documents have been filtered check_relevance
+        # We will re-generate a new query
+        print(
+            "---DECISION: ALL APPLICATIONS ARE NOT RELEVANT TO BUSINESS QUERY, TRANSFORM QUERY---"
+        )
+        return "transform_query"
+    else:
+        # We have relevant documents, so generate answer
+        print("---DECISION: GENERATE---")
+        return "generate"
+
+##Action-4a Generate if relevant applications found
+def generate(state:Task2State, config: RunnableConfig):
+    """
+    Generate answer
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key
+        added to state, identified_asis, that contains LLM generation
+    """
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
+    
+    print("---GENERATE---")
+    landscape_asis = state['landscape_asis']
+
+    values =  { 
+        "business_query": state['business_query'],
+        "applications": state['identified_asis']
+        }
+
+    parser = PydanticOutputParser(pydantic_object=LandscapeAsIs)
+
+    hub_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_landscape_business_query')
+    hub_prompt = hub_prompt.partial(
+        format_instructions=parser.get_format_instructions(),
+    )
+
+    model.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(model,hub_prompt,values))
+
+    task_2_generate = hub_prompt | model | parser
+    generated_asis = task_2_generate.invoke(input=values, config={"recursion_limit":configuration.recursion_limit})
+
+    name = state['next']
+    
+    return {
+        "messages": [AIMessage(content=str(generated_asis.identified_asis), name=name)],
+        "landscape_asis": landscape_asis, 
+        "business_query": state['business_query'],
+        "identified_asis": generated_asis.identified_asis
+    }
+
+##Action-4b Re-write query otherwise
+def transform_query(state:Task2State, config: RunnableConfig):
+    """
+    Transform the query to produce a better question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Updates question key with a re-phrased question
+    """
+    # Get any user-provided configs - LLM model in use
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
+
+    print("---TRANSFORM QUERY---")
+    business_query = state['business_query']
+
+    # Re-write question
+    response = question_rewriter(model).invoke(
+        {"user_question": business_query, "target": "vectorstore"},
+    )
+    
+    generated_question = extract_topic_from_business_input(response.content)
+    better_question = generated_question['rephrased']
+
+    if better_question == None: better_question = business_query 
+
+    name = state['next']
+
+    return {
+        "messages": [AIMessage(content=better_question, name=name)],
+        "business_query": better_question
+    }
+
+##Action-5 Grade final response
+def grade_generation_v_documents_and_question(state:Task2State, config: RunnableConfig):
+    """
+    Determines whether the generation is grounded in the landscape_asis and answers business query.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Decision for next node to call
+    """
+
+    # Get any user-provided configs - LLM model in use
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
+
+
+    print("---CHECK HALLUCINATIONS---")
+    business_query = state['business_query']
+    landscape_asis = state['landscape_asis']
+    identified_asis = state['identified_asis']
+    generated_asis = [item.application for item in identified_asis] if identified_asis else []
+
+    score = hallucination_grader(str(landscape_asis),generated_asis)
+
+    if len(score)==0:
+        print("---DECISION: IDENTIFIED APPLICATION(s) IS GROUNDED IN LANDSCAPE ASIS---")
+        # Check question-answering
+        print("---GRADE GENERATION vs QUESTION---")
+
+        values =  {"business_query": business_query, "application": identified_asis}
+        prompt = answer_grader()
+        model.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(model,prompt,values))
+        grader_chain = prompt | model
+        score = grader_chain.invoke(values)        
+        extracted_answer = extract_structured_output(score.content)
+        if extracted_answer is not None: ##REVIEW PROMPT W/ LLAMA3.1-70B
+            grade = extracted_answer['binary_score']
+        else:
+            grade = "no"
+
+        if grade == "yes":
+            print("---DECISION: APPLICATION ADDRESSES BUSINESS QUERY---")
+            return "useful"
+        else:
+            print("---DECISION: APPLICATION DOES NOT ADDRESS BUSINESS QUERY---")
+            return "not useful"
+    else:
+        print("---DECISION: IDENTIFIED ASIS IS NOT GROUNDED IN LANDSCAPE ASIS, RE-TRY---")
+        print(f"---HALLUCINATIONS: {score}---")
+        return "not supported"
+
+##Action-6 Analyse gap between current state and the desired future state - identified capabilities
+def grade_landscape_asis_v_capability_gap(state:Task2State, config: RunnableConfig):
+    """
+    Analyse any gap between existent applications and identified business capability to address the business query.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Updates landscape_gap key with capability gap status
+    """
+    
+    # Get any user-provided configs - LLM model in use
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
+
+    print("---CHECK SUPPORT IDENTIFIED APP TO BUSINESS CAPABILITY---")
+    
+    parser = PydanticOutputParser(pydantic_object=CapabilityGap)
+
+    hub_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_capability_gap')
+    hub_prompt = hub_prompt.partial(
+        format_instructions=parser.get_format_instructions(),
+    )
+    task_2_landscape_gap = hub_prompt | model | parser
+
+    #capability_gap_grader
+    if state['identified_asis']:
+        content = ';'.join(str(app) for app in state['identified_asis'])
+    else:
+        content = "No applications identified"
+
+    if state['biz_capability']:
+        capability = ', '.join(ast.literal_eval(state['biz_capability'])).replace("'", ", ")
+        #bcm = ast.literal_eval(str(state['biz_capability']))
+        #capability = bcm[1:-1].replace("'","")
+        #capability = state['biz_capability']
+    else:
+        capability = "No business capabilities identified"
+    
+    values = {
+        "application": content,
+        "capability": capability
+        }
+
+    model.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(model,hub_prompt,values))
+
+    extracted_gap = task_2_landscape_gap.invoke(input=values, config={"recursion_limit":configuration.recursion_limit})
+
+    for item in extracted_gap.capability_status:
+        print(f"---CAPABILITY: {item.capability}  SUPPORT: {item.support}---")
+
+    return {
+        "messages": [AIMessage(content=str(state['messages']), name=state['next'])],
+        "landscape_gap": extracted_gap #landscape_gap.content
+        }
+
+##TASK-2 Graph
+task2_builder = StateGraph(Task2State)
+
+# Define the nodes
+task2_builder.add_node("assess_landscape", retrieve)  # retrieve
+task2_builder.add_node("grade_landscape_asis", grade_landscape_asis)  # grade documents
+task2_builder.add_node("generate", generate)  # generate
+task2_builder.add_node("transform_query", transform_query)  # transform_query
+task2_builder.add_node("grade_landscape_gap", grade_landscape_asis_v_capability_gap) #analyse asis gap
+
+# Build graph
+task2_builder.set_entry_point("assess_landscape")
+
+task2_builder.add_edge("assess_landscape", "grade_landscape_asis")
+task2_builder.add_conditional_edges(
+    "grade_landscape_asis",
+    decide_to_generate,
+    {
+        "transform_query": "transform_query",
+        "generate": "generate",
+    },
+)
+task2_builder.add_edge("transform_query", "assess_landscape")
+task2_builder.add_conditional_edges(
+    "generate",
+    grade_generation_v_documents_and_question,
+    {
+        "not supported": "generate",
+        "useful": "grade_landscape_gap",
+        "not useful": "transform_query",
+    },
+)
+
+task2_builder.add_edge("grade_landscape_gap", END)
+
+# Compile
+task2_graph = task2_builder.compile()
+task2_graph.name = "Togaf_assess_asis_graph"

ea4all/src/ea4all_gra/togaf_task2/state.py

@@ -0,0 +1,50 @@
+from typing_extensions import (
+    Annotated
+)
+import operator
+from typing import (
+    Optional,
+    Annotated, 
+    Sequence,
+    List
+)
+from dataclasses import dataclass
+
+from langchain_core.messages import (
+    BaseMessage
+)
+
+from langchain_core.documents import Document
+
+from ea4all.src.ea4all_gra.data import (
+    BusinessCapability, 
+    CapabilityGap,
+    LandscapeAsIs,
+)
+
+from ea4all.src.ea4all_gra.state import InputState
+
+# Task-2 Graph State
+@dataclass(kw_only=True)
+class Task2State(InputState):
+    """
+    Represents the landscape assessement state of our graph.
+
+    Attributes:
+        message: a message is added after each team member finishes
+        team_members: the team members are tracked so they are aware of the others' skill-sets
+        next: used to route work. The supervisor calls a function that will update this every time it makes a decision
+        business_query: identified business capabilities
+        landscape_asis: list of applications
+        identified_asis: LLM generation
+        capability: list of business capabilities required to support intent and requirements
+        landscape_gap: business capability support gap
+    """
+    
+    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    team_members: Optional[List[str]]
+    landscape_asis: Optional[List[Document]]
+    identified_asis: Optional[LandscapeAsIs]
+    biz_capability: Optional[BusinessCapability]
+    landscape_gap: Optional[CapabilityGap]
+    next: Optional[str]

ea4all/src/ea4all_gra/togaf_task3/graph.py

@@ -0,0 +1,246 @@
+from markdownify import markdownify as md
+from graphviz import Source
+
+#core libraries
+from langchain_core.runnables import RunnableConfig, RunnableGenerator
+from langchain_core.messages import (
+    AIMessage,
+)
+
+from langchain import hub
+
+from langgraph.graph import (
+    END, 
+    StateGraph,
+)
+
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration
+
+from ea4all.src.shared.utils import (
+    get_llm_client,
+    set_max_new_tokens,
+    get_predicted_num_tokens_from_prompt,
+    extract_detailed_business_requirements,
+    load_mock_content,
+    extract_principles,
+)
+
+from ea4all.src.ea4all_gra.data import (
+    Principles,
+)
+
+from ea4all.src.ea4all_gra.togaf_task3.state import Task3State
+
+# Task-3: Generate reference architecture Vision and Target first iteration
+def generate_principles(state: Task3State, config: RunnableConfig):
+
+    #Extract Business, Technnology and Architecture Principles
+    strategic_principles = md(str(load_mock_content('strategic_principles.txt'))) ##REFACTORING NEEDED
+    
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(
+        configuration.togaf_model,
+        api_base_url=configuration.api_base_url,
+    )
+ 
+    model.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(model,extract_principles(Principles),{"strategic_principles": strategic_principles}))
+    
+    ##RE-use business reqs extractor
+    identified_principles = extract_detailed_business_requirements(model, Principles, "architecture principles", {"business_input": strategic_principles})
+    
+    name = state.get('next')
+    return {
+        "messages": [AIMessage(content=str(identified_principles), name=name)],
+        "principles": identified_principles,
+        "business_query": state.get('business_query'),
+        "business_goal": state.get('intent'),
+        "business_stakeholder": state.get('stakeholder'),
+        "biz_capability": state.get('biz_capability'),
+        "requirement": state.get('requirement'),
+        "user_journey": state.get('userjourney'),
+        "landscape_asis": state.get('landscape_asis'),
+        "identified_asis": state.get('identified_asis'),
+        "landscape_gap": state.get('landscape_gap')
+    }
+
+async def stream_vision_target(state: Task3State, config: RunnableConfig):
+    ##MAX_TOKENS OPTIMISATION 2024-07-08
+
+    inputs = {}
+    async for s in state:
+        inputs['intent'] = s.get('intent')
+        inputs['stakeholder'] = s.get('stakeholder')
+        inputs['biz_capability'] = s.get('biz_capability')
+        inputs['requirement'] = s.get('requirement')
+        inputs['userjourney'] = s.get('userjourney')
+        inputs['identified_principles'] = s.get('principles')
+        inputs['landscape_asis'] = s.get('landscape_asis')
+        inputs['identified_asis'] = s.get('identified_asis')
+        inputs['landscape_gap'] = s.get('landscape_gap')
+
+    # Prompt
+    vision_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_vision_target')
+   
+    values =  {
+            "business_goal": inputs['intent'],
+            "business_stakeholder": inputs['stakeholder'],
+            "business_capability": inputs['biz_capability'],
+            "principles": inputs['identified_principles'],
+            "requirement": inputs['requirement'],
+            "user_journey": inputs['userjourney'],
+            "landscape_asis": inputs['landscape_asis'],
+            "identified_asis": inputs['identified_asis'],
+            "landscape_gap": inputs['landscape_gap']
+        }
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(
+        configuration.togaf_model,
+        api_base_url=configuration.api_base_url,
+        streaming=configuration.streaming,
+    )
+
+    model.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(model,vision_prompt,values))
+    vision_chain = vision_prompt | model
+ 
+    async for output in vision_chain.astream(values):
+        yield(output)
+
+async def generate_vision(state: Task3State):
+    """
+    Generate answer
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, generation, that contains LLM generation
+    """
+
+    gen = RunnableGenerator(stream_vision_target).with_config(tags=["gra_stream"])
+    
+    generation=""
+    async for message in gen.astream(state):
+        generation = ''.join([generation,message.content])
+
+    name = state.get('next')
+
+    return {
+        "messages": [AIMessage(content=generation, name=name)],
+        "principles": state.get('principles'),
+        "business_query": state.get('business_query'),
+        "intent": state.get('intent'),
+        "stakeholder": state.get('stakeholder'),
+        "biz_capability": state.get('biz_capability'),
+        "requirement": state.get('requirement'),
+        "userjourney": state.get('userjourney'),
+        "landscape_asis": state.get('landscape_asis'),
+        "identified_asis": state.get('identified_asis'),
+        "landscape_gap": state.get('landscape_gap'),
+        "vision_target": generation
+    }
+
+def generate_architecture_runway(state: Task3State, config: RunnableConfig):
+    stakeholder = state.get('stakeholder')
+    biz_capability = state.get('biz_capability')
+    userjourney = state.get('userjourney')
+    identified_asis = state.get('identified_asis')
+    intent = state.get('intent')
+
+    # Prompt
+    runway_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_architecture_runway')
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+    model = get_llm_client(
+        configuration.togaf_model,
+        api_base_url=configuration.api_base_url,
+    )
+ 
+    values =  {
+        "stakeholder": stakeholder,
+        "business_capability": biz_capability,
+        "userjourney": userjourney,
+        "identified_asis": identified_asis,
+        "intent": intent,
+    }
+
+    ##Issue w/ llama-3.2-vision and ChatOpenAI token limits
+    model.max_tokens = int((configuration.max_tokens - get_predicted_num_tokens_from_prompt(model,runway_prompt,values))*0.95)
+    
+    vision_chain = runway_prompt | model
+    architecture_runway = vision_chain.invoke(input=values)
+
+    name = state.get('next')
+
+    return {
+        "messages": [AIMessage(content=architecture_runway.content, name=name)],
+        "architecture_runway": architecture_runway.content
+    }
+
+def save_diagram(state: Task3State, config: RunnableConfig, fmt=["svg","png"]): 
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    #_config = config.get('configurable')
+    #if _config is not None:
+    #    thread_id = _config['thread_id']
+    #    output_img = "togaf_runway_" + str(thread_id)
+    #else:
+    #    output_img = "Error generating file name!"
+
+    input_img = state['architecture_runway']
+    output_img = "togaf_runway_" + str(config['configurable']['thread_id'])
+
+    try:
+        x=Source(
+            source=input_img,
+            filename=output_img,
+            format=fmt[0]
+        )
+        response = x.render(
+            cleanup=True,
+            directory=configuration.ea4all_images,
+            format=fmt[1], 
+            view=False,
+            ).replace('\\', '/')
+    except Exception as e:
+        response=f"Error: Agent couldn't parse the diagram at this time! {e} \n {output_img} \n {input_img}"
+
+    return{"architecture_runway": response}
+
+def generate_reference_architecture(state: Task3State):
+    ##BY PASS to generate principles
+    return {
+        "business_query": state.get('business_query'),
+        "intent": state.get('intent'),
+        "stakeholder": state.get('stakeholder'),
+        "biz_capability": state.get('biz_capability'),
+        "requirement": state.get('requirement'),
+        "userjourney": state.get('userjourney'),
+        "landscape_asis": state.get('landscape_asis'),
+        "identified_asis": state.get('identified_asis'),
+        "landscape_gap": state.get('landscape_gap'),
+      }
+
+##TASK-3 Graph
+workflow = StateGraph(Task3State)
+
+# Define the nodes
+workflow.add_node("generate_reference_architecture", generate_reference_architecture)  # business, technology, architecture principles
+workflow.add_node("generate_principles", generate_principles)  # business, technology, architecture principles
+workflow.add_node("generate_vision_target", generate_vision)  # architecture vision and target
+workflow.add_node("generate_architecture_runway", generate_architecture_runway) # draw high-level diagram target state
+workflow.add_node("save_diagram", save_diagram)
+
+# Build graph
+workflow.add_edge("generate_reference_architecture", "generate_principles")
+workflow.add_edge("generate_principles", "generate_vision_target")
+workflow.add_edge("generate_vision_target", "generate_architecture_runway")
+workflow.add_edge("generate_architecture_runway","save_diagram")
+workflow.add_edge("save_diagram", END)
+
+#Entry point
+workflow.set_entry_point("generate_reference_architecture")
+
+# Compile
+task3_graph = workflow.compile()
+task3_graph.name = "Togaf_generate_tobe_graph"

ea4all/src/ea4all_gra/togaf_task3/state.py

@@ -0,0 +1,65 @@
+from typing_extensions import (
+    Annotated
+)
+import operator
+from typing import (
+    Optional,
+    Annotated, 
+    Sequence,
+    List
+)
+from dataclasses import dataclass
+
+from langchain_core.messages import (
+    BaseMessage
+)
+
+from ea4all.src.ea4all_gra.data import (
+    BusinessCapability, 
+    CapabilityGap,
+    LandscapeAsIs,
+    StakeholderList,
+    Principles,
+    ListObjective,
+    ListRequirement,
+    UserJourney,
+)
+
+from ea4all.src.ea4all_gra.state import InputState
+
+# Task-3 Graph State
+@dataclass(kw_only=True)
+class Task3State(InputState):
+    """
+    Represents the Reference Architecture state of our graph.
+
+    Attributes:
+        message: a message is added after each team member finishes
+        team_members: the team members are tracked so they are aware of the others' skill-sets
+        next: used to route work. The supervisor calls a function that will update this every time it makes a decision
+        business_query: business demand to be delivered 
+        principles: list of principles to the architecture work
+        requirement: list of business requirements
+        intent: business objective, goal
+        user_journey: list of user journeys
+        stakeholder: list of stakeholder and their concerns
+        capability: list of business capabilities to deliver intent and requirements
+        landscape_asis: list of potential applications to support business query  
+        identified_asis: identified target applications
+        landscape_gap: list of capabilities not supported by as-is landscape
+    """
+
+    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    team_members: Optional[List[str]]
+    landscape_asis: Optional[List[str]]
+    identified_asis: Optional[LandscapeAsIs]
+    biz_capability: Optional[BusinessCapability]
+    landscape_gap: Optional[CapabilityGap]
+    stakeholder: Optional[StakeholderList]
+    principles: Optional[Principles]
+    requirement: Optional[ListRequirement]
+    intent: Optional[ListObjective]
+    userjourney: Optional[UserJourney]
+    vision_target: Optional[str]
+    architecture_runway: Optional[str]
+    next: Optional[str]

ea4all/src/ea4all_gra/utils.py

@@ -0,0 +1,125 @@
+import gradio as gr
+
+import asyncio
+import threading
+
+def assign_event_loop_to_thread():
+    """
+    Explicitly assign a new event loop to the current thread
+    This method can be called at the start of thread-based operations
+    """
+    try:
+        # Try to get the current event loop
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        # If no event loop exists, create a new one
+        loop = asyncio.new_event_loop()
+        
+        # Set the new event loop for the current thread
+        asyncio.set_event_loop(loop)
+  
+    return loop
+
+class AsyncInterruptHandler:
+    def __init__(self):
+        # Assign event loop at initialization
+        self.loop = assign_event_loop_to_thread()
+        self.input_queue = asyncio.Queue()
+        self.event = asyncio.Event()
+
+        self.user_feedback = None
+        self.interface = None
+        self.interface_thread = None
+
+        # Get or create the event loop
+        try:
+            self.loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self.loop)
+
+    async def close_interface_with_timeout(self):
+    # Get the current thread's event loop
+        try:
+            print(f"NOT Closing interface: {self.interface.is_callable()}")
+            
+        except asyncio.TimeoutError:
+            print("Interface closure timed out")
+        except Exception as e:
+            print(f"Error closing interface: {e}")
+
+    def launch_gradio_interface(self):
+        def run_interface():
+            # Explicitly assign event loop for this thread
+            assign_event_loop_to_thread()
+            
+            # Get the current thread's event loop
+            current_loop = asyncio.get_event_loop()
+            
+            try:
+                # Run the interface creation coroutine
+                current_loop.run_until_complete(self._create_and_launch_interface())
+            except Exception as e:
+                print(f"Error in run_interface: {e}")
+        
+        # Create and start the thread
+        self.interface_thread = threading.Thread(target=run_interface, daemon=True)
+        self.interface_thread.start()
+
+    async def _create_and_launch_interface(self):
+        title = 'User Input'
+        description = 'Please provide input'
+
+        async def submit_input(user_feedback):
+            asyncio.run_coroutine_threadsafe(self.input_queue.put(user_feedback), self.loop)
+            self.event.set()
+            
+            print(f"User Provided input: {user_feedback}")
+            
+            return user_feedback
+
+        with gr.Blocks() as demo:
+            gr.Markdown(f"###{title}")
+            gr.Markdown(f"**{description}")
+
+            input_component = gr.Textbox(label="Your input")
+            submit_btn = gr.Button("Submit")
+            output = gr.Textbox(label="Status")
+
+            submit_btn.click(
+                submit_input, 
+                inputs=input_component, 
+                outputs=output
+            )
+
+        self.event = asyncio.Event()
+        self.event.clear()
+        self.user_feedback = None
+        
+        self.interface = demo
+        self.interface.launch(inbrowser=True)
+
+    async def handle_interrupt(self):
+        self.launch_gradio_interface()
+
+        try:
+            # Use the current loop's queue and event
+            self.user_feedback = await asyncio.wait_for(
+                self.input_queue.get(), 
+                timeout=300.0,  # 5-minute timeout
+            )
+
+            print(f"Finished waiting for user input {self.user_feedback}")
+
+            return self.user_feedback
+        
+        except asyncio.TimeoutError:
+            print("Gradio interface timed out")
+            return None
+        
+        except Exception as e:
+            print(f"Error in handle_interrupt: {e}")
+            return None
+        
+        finally:
+            await self.close_interface_with_timeout()

ea4all/src/ea4all_indexer/__init__.py

@@ -0,0 +1,5 @@
+"""Index Graph Module."""
+
+#from ea4all_indexer.graph import ea4all_indexer
+
+#__all__ = ["ea4all_indexer"]

ea4all/src/ea4all_indexer/configuration.py

@@ -0,0 +1,22 @@
+"""Define the configurable parameters for the index graph."""
+
+from dataclasses import dataclass, field
+
+from ea4all.src.shared.configuration import BaseConfiguration
+
+# This file contains sample APPLICATIONS to index
+DEFAULT_APM_CATALOGUE = "APM-ea4all (test-split).xlsx"
+
+@dataclass(kw_only=True)
+class IndexConfiguration(BaseConfiguration):
+    """Configuration class for indexing and retrieval operations.
+
+    This class defines the parameters needed for configuring the indexing and
+    retrieval processes, including embedding model selection, retriever provider choice, and search parameters.
+    """
+    apm_catalogue: str = field(
+        default=DEFAULT_APM_CATALOGUE,
+        metadata={
+            "description": "The EA4ALL APM default Vectorstore index name."
+        },
+    )

ea4all/src/ea4all_indexer/graph.py

@@ -0,0 +1,57 @@
+"""This "graph" simply exposes an endpoint for a user to upload docs to be indexed."""
+"""Changelog: 2025-06-03
+- Refactored code to fix problems with linter and type checking (Standard mode)
+- Refactored to use langgraph state management for MCP compatibility.
+- Enabled input BYOD (Bring Your Own Data) for indexing.
+"""
+
+from typing import Optional
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph import END, START, StateGraph
+
+from ea4all.src.ea4all_indexer.configuration import IndexConfiguration
+from ea4all.src.ea4all_indexer.state import InputState, OutputState, OverallState
+from ea4all.src.shared import vectorstore
+from ea4all.src.shared.configuration import BaseConfiguration
+
+async def index_docs(
+    state: InputState, *, config: RunnableConfig
+) -> dict[str, str]:
+    """Asynchronously index documents in the given state using the configured retriever.
+
+    This function takes the documents from the state, ensures they have a user ID,
+    adds them to the retriever's index, and then signals for the documents to be
+    deleted from the state.
+
+    If docs are not provided in the state, they will be loaded
+    from the configuration.docs_file JSON file.
+
+    Args:
+        state (IndexState): The current state containing documents and retriever.
+        config (Optional[RunnableConfig]): Configuration for the indexing process.r
+    """
+    if not config:
+        raise ValueError("Configuration required to run index_docs.")
+
+    #configuration = IndexConfiguration.from_runnable_config(config)
+
+    with vectorstore.make_retriever(config) as retriever:
+        if len(retriever.vectorstore.docstore._dict) == 0:
+            apm_docs = vectorstore.get_apm_excel_content(config, file=state.path)
+            await retriever.aadd_documents(apm_docs)
+            retriever.vectorstore.save_local(
+                folder_path=getattr(config, "ea4all_store", BaseConfiguration.ea4all_store), 
+                index_name=getattr(config, "apm_faiss", BaseConfiguration.apm_faiss)
+            )
+
+    return {"docs": "delete"}
+
+# Define the graph
+builder = StateGraph(OverallState, input=InputState, output=OutputState, config_schema=IndexConfiguration)
+builder.add_node("apm_indexer",index_docs)
+builder.add_edge(START, "apm_indexer")
+
+# Compile into a graph object that you can invoke and deploy.
+indexer_graph = builder.compile()
+indexer_graph.name = "EA4ALL APM Indexer"

ea4all/src/ea4all_indexer/state.py

@@ -0,0 +1,44 @@
+"""State management for the index graph."""
+
+from dataclasses import dataclass
+from typing import Annotated, Optional
+
+from langchain_core.documents import Document
+
+from ea4all.src.shared.state import reduce_docs
+
+@dataclass(kw_only=True)
+class InputState:
+    """Represents the input state for the index graph.
+
+    This class is used to pass the input documents to the index graph.
+    It contains a single field, `path`, which is the source of documents.
+    """
+
+    path: Optional[str] = None
+    """Document source path to be indexed by the graph."""
+
+
+# The index state defines the simple IO for the single-node index graph
+@dataclass(kw_only=True)
+class OutputState:
+    """Represents the state for document indexing and retrieval.
+
+    This class defines the structure of the index state, which includes
+    the documents to be indexed and the retriever used for searching
+    these documents.
+    """
+
+    docs: Annotated[list[Document], reduce_docs]
+    """A list of documents that the agent can index."""
+
+@dataclass(kw_only=True)
+class OverallState(InputState):
+    """Represents the overall state of the index graph.
+
+    This class combines the input and output states, allowing for
+    both input documents and indexed documents to be managed within
+    the same state.
+    """
+
+    pass

ea4all/src/ea4all_vqa/configuration.py

@@ -0,0 +1,42 @@
+"""Define the configurable parameters for the VQA agent."""
+
+#'from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+#'from shared.configuration import BaseConfiguration
+from typing import Annotated
+
+from ea4all.src.shared.configuration import BaseConfiguration
+
+@dataclass(kw_only=True)
+class AgentConfiguration(BaseConfiguration):
+    """The configuration for the agent."""
+
+    supervisor_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="gpt-4o-mini",
+        metadata={
+            "description": "The language model used for supervisor agents. Should be in the form: provider/model-name."
+        },
+    )
+
+    vqa_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="gpt-4o-mini", #meta-llama/llama-3.2-11B-Vision-Instruct",
+        metadata={
+            "description": "The language model used for visual questions and answering. Should be in the form: provider/model-name."
+        },
+    )
+
+    vqa_max_tokens: Annotated[int, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default=4096,
+        metadata={
+            "description": "The maximum number of tokens allowed for the visual question and answer model."
+        },
+    )
+
+    ea4all_ask_human: Annotated[str, {"__template_metadata__": {"kind": "integration"}}] = field(
+        default="Frontend",
+        metadata={
+            "description": "Trigger EA4ALL ask human input via interruption or receive from external frontend."
+        },
+    )

ea4all/src/ea4all_vqa/graph.py

@@ -0,0 +1,401 @@
+"""This graph implements a Vision Question Answering (VQA) agent for architecture diagrams and flowcharts."""
+"""Changelog: 
+- Build the VQA Graph
+- Setup state shared between nodes
+- DiagramSupervisor function disabled, direct call to vqa_diagram
+- Retrofitied supervisor function and added build_vqa_graph
+#2025-06-03
+- Refactored code to fix problems with linter and type checking (Standard mode)
+- Refactored to use langgraph state management for MCP compatibility.
+- Enabled input BYOD (Bring Your Own Data) for indexing.
+"""
+#core libraries
+from langchain_core.runnables import RunnableConfig
+from langchain_core.prompts.chat import ChatPromptTemplate
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables.base import RunnableLambda, RunnableSerializable
+from langchain_core.runnables import RunnableConfig
+from langchain_core.language_models.chat_models import BaseChatModel
+
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    ToolMessage,
+)
+
+#pydantic
+from pydantic import BaseModel, Field
+
+from json import JSONDecodeError
+
+from typing import (
+    Annotated, 
+)
+from typing_extensions import Literal, TypedDict
+
+#Graphs, Agents
+from langchain.agents import tool
+from langchain_core.agents import AgentFinish
+from langgraph.graph import (
+    START,
+    END, 
+    StateGraph,
+)
+from langgraph.prebuilt import ToolNode, tools_condition, InjectedState
+from langgraph.types import Command
+
+#import APMGraph packages
+from ea4all.src.ea4all_vqa.configuration import AgentConfiguration
+from ea4all.src.ea4all_vqa.state import InputState, OutputState, OverallState
+
+#import shared packages
+from ea4all.src.shared.configuration import BaseConfiguration
+from ea4all.src.shared.utils import (
+    get_llm_client, 
+    _get_formatted_date,
+    get_raw_image,
+    extract_topic_from_business_input,
+    set_max_new_tokens,
+    get_predicted_num_tokens_from_prompt,
+    _join_paths,
+)
+
+import spaces
+
+##Diagram Graph Tools 
+#Data model Sageguarding
+@tool("diagram_safeguard")
+class DiagramV2S(BaseModel):
+    """Check whether the image provided is an architecture diagram or flowchart and safe to be processed."""
+    isArchitectureImage: bool = Field(...,description="Should be True if an image is an architecture diagram or flowchart, otherwise False.")
+    isSafe: bool = Field(...,description="Should be True if image or question are safe to be processed, False otherwise")
+    description: str = Field(description="One sentence describing the reason for being categorised as unsafe or not an architecture image.")
+
+@tool("vqa_diagram", response_format="content")
+@spaces.GPU
+async def vqa_diagram(next:str, state: Annotated[OverallState, InjectedState], config: RunnableConfig):
+    """Diagram Vision Question Answering"""
+
+    print(f"---AGENT VQA PROCESSING QUESTION & ANSWERING---")
+
+    # Get any user-provided configs - LLM model in use
+    configuration = AgentConfiguration.from_runnable_config(config)
+    llm = get_llm_client(
+        model=configuration.vqa_model, 
+        api_base_url=configuration.api_base_url, 
+        streaming=configuration.streaming, 
+    )
+
+    question = getattr(state, "question")
+    raw_image = get_raw_image(getattr(state,'image'))
+
+    user_message = HumanMessage(
+            content=[
+                {"type": "text", "text": f"{question}"},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{raw_image}"},
+                },
+            ],
+        )
+    prompt = ChatPromptTemplate.from_messages([user_message])
+    values = {"question": question}
+
+    #llm.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(llm, prompt, values))
+    chain = prompt | llm
+
+    # Not streaming the response to MCP Inspector
+    #async for message in chain.astream(input=values, config={"tags": ["vqa_stream"]}, kwargs={"max_tokens": configuration.vqa_max_tokens}):
+    #    yield message
+
+    response = await chain.ainvoke(input=values, config={"tags": ["vqa_stream"]}, kwargs={"max_tokens": configuration.vqa_max_tokens})
+
+    ## When exposed as MCP tool, output schema should as simple as possible as output is serialized to a single string
+    return response.content
+
+##Supervisor Agent Function custom parse with tool calling response support
+def parse(output: ToolMessage) -> dict | AgentFinish:
+
+    # Parse out the function call
+    print("---PARSING SUPERVISOR AGENT OUTPUT---")
+    print(output.content)
+    try:
+        response = extract_topic_from_business_input(output.content)
+        _next = response['parameters']['next']
+    except JSONDecodeError:
+        return AgentFinish(return_values={"output": output.content}, log=str(output.content))
+    
+    # If no function was selected, return to user
+    if _next == "FINISH": 
+        return AgentFinish(return_values={"output": output.content}, log=str(output.content))
+
+    # If the DiagramTagging function was selected, return to the user with the function inputs
+    tool_call = {"name": "vqa_diagram", "args": {"next": _next}, "id": "1", "type": "tool_call"}
+
+    print(f"---ROUTING QUESTIONS TO {_next}---")
+    print(output.content)
+
+    return {
+        "messages": [AIMessage("", tool_calls=[tool_call])],
+        "next": _next,
+    }
+
+#Create Safeguarding agent
+def create_safeguarding_agent(llm, system_message: str, question: str, raw_image: str):
+    """Create an LLM-based safeguarding checker."""
+    # LLM with function call
+    structured_llm_safeguard = llm.with_structured_output(DiagramV2S)
+
+    human_message = HumanMessage(content=[
+        {"type": "text", "text": f"{question}"},
+        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{raw_image}"}},
+    ])
+
+    safeguard_prompt = ChatPromptTemplate.from_messages(
+        [
+            human_message,
+            ("system", system_message),
+        ]
+    )
+
+    diagram_safeguard = safeguard_prompt | structured_llm_safeguard
+
+    return diagram_safeguard
+
+#Safeguard custom parse
+def safeguard_check(state:OverallState, config:RunnableConfig) -> dict:
+    configuration = AgentConfiguration.from_runnable_config(config)
+    llm = get_llm_client(configuration.supervisor_model)
+
+    #'raw_image = state.messages[0].content[0]['image_url']['url'].split(',')[1]
+    question = getattr(state, "question", "Describe the image")
+    raw_image = get_raw_image(getattr(state,'image', _join_paths(configuration.ea4all_images,'multi-app-architecture.png')))
+
+    system_message = (
+    "Act as a safeguarding agent to check whether the image provided is an architecture diagram or flowchart and safe to be processed. "
+    "You will be provided with a question and an image. "   
+    "You should return a JSON object with the following fields: "
+    "'isArchitectureImage':bool, 'isSafe': bool, 'description': str. "
+    "The 'isArchitectureImage' field should be True if the image is an architecture diagram or flowchart, otherwise False. "
+    "The 'isSafe' field should be True if the image or question are safe to be processed, False otherwise. "
+    "The 'description' field should contain a one sentence description of the reason for being categorised as unsafe or not an architecture image. "
+    "If the image is not an architecture diagram or flowchart, you should say it is not an architecture image as 'description' field. "
+    "If the image is not safe to be processed, you should say it is unsafe as 'description' field. "
+    )
+
+    safeguard_checker = create_safeguarding_agent(
+        llm,
+        system_message,
+        question,
+        raw_image        
+        )
+    
+    input = {"question": question, "raw_image": raw_image}
+    result = safeguard_checker.invoke(input=input, config=config)
+    
+    return {"safety_status": result}
+
+def call_finish(state:OverallState, config:RunnableConfig) -> dict:
+
+    return {
+        "messages": [],
+        "safety_status": getattr(state, 'safety_status', {}),
+    } 
+
+def make_supervisor_node(model: BaseChatModel, members: list[str]) -> RunnableLambda:
+    options = ["FINISH"] + members
+    
+    system_prompt = (
+        "You are an enterprise architecture team supervisor tasked to manage a conversation between the following members: "
+        "[diagram_description, diagram_object, diagram_improvement, diagram_risk]. "
+        "Given the user request, use the function below to respond with team member to act next. "    
+        " If none of team member can be used, select 'FINISH'."
+    )
+
+    class Router(TypedDict):
+        """Worker to route to next. If no workers needed, route to FINISH."""
+        next: Literal['FINISH', 'diagram_description', 'diagram_object', 'diagram_improvement', 'diagram_risk']
+
+    async def supervisor_node(state: OverallState, config: RunnableConfig) -> dict | AgentFinish:
+
+        """An LLM-based router."""
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ] + getattr(state, 'messages')
+        
+        response = await model.with_structured_output(Router, include_raw=True).ainvoke(messages, config=config)
+
+        if isinstance(response, dict):
+            if response['parsed']['next'] == "FINISH": 
+                return AgentFinish(return_values={"output": response['raw']}, log=response['raw']['content'])
+
+            # If the DiagramTagging function was selected, return to the user with the function inputs
+            tool_call = {"name": "vqa_diagram", "args": {"next": response['parsed']['next']}, "id": "1", "type": "tool_call"}
+
+            return {
+                "messages": [AIMessage("", tool_calls=[tool_call])],
+                "next": response['parsed']['next'],
+            }
+        else:
+            return AgentFinish(return_values={"output": response}, log=str(response))
+
+    return RunnableLambda(supervisor_node)
+
+#Create team supervisor
+def create_team_supervisor(state:OverallState, config:RunnableConfig) -> RunnableSerializable: #Adding the parameter config:RunnableConfig causing Channel error
+    """An LLM-based router."""
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+    llm = get_llm_client(
+        configuration.vqa_model, 
+        api_base_url=configuration.api_base_url,
+    )
+
+    # Supervisor Tool Prompts
+    system_prompt = f"""
+    Environment: ipython
+    Cutting Knowledge Date: December 2023
+    Today Date: {_get_formatted_date()}
+    """
+
+    user_prompt = """
+    You are an enterprise architecture team supervisor tasked to manage a conversation between the following members:
+    ["diagram_description", "diagram_object", "diagram_improvement", "diagram_risk"].
+    Given the user request, use the function below to respond with team member to act next.    
+    If none of team member can be used, select "FINISH".
+    Function (in JSON format):
+    {
+        "type": "function", "function": {
+            "name": "route",
+            "description": "Select one of the available tools that should be used next.",
+            "parameters": {
+                "title": "routeSchema",
+                "type": "object",
+                "properties": {
+                    "next": {
+                        "title": "Next",
+                        "anyOf": [
+                            {"enum": ["FINISH", "diagram_description", "diagram_object", "diagram_improvement", "diagram_risk"]},
+                        ],
+                    },
+                },
+                "required": ["next"],
+            },
+        }
+    }
+    """
+
+    messages = [
+        ("system", system_prompt),
+        ("human", "{user_prompt}"),
+        ("human", "{question}"),    
+    ]
+
+    prompt = ChatPromptTemplate.from_messages(messages).partial(
+        user_prompt=user_prompt)
+
+    llm.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(llm, prompt, {"question":state.question}))
+
+    supervisor_agent = (
+        prompt | 
+        llm | 
+        parse
+    )
+
+    return supervisor_agent
+
+# The following functions interoperate between the top level graph state
+# and the state of the research sub-graph
+# this makes it so that the states of each graph don't get intermixed
+def enter_graph(state:OverallState, config:RunnableConfig) -> Command[Literal['safeguard_check']]:
+
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    messages = [
+        HumanMessage(content=state.question) #messages[-1]['content']),
+    ]
+
+    #if not configuration.ea4all_ask_human == "interrupt":
+    #    raw_image = state.messages[0].content[0]['image_url']['url'].split(',')[1]
+    #else:
+    #    image = getattr(state,'image', "")
+    #    raw_image = image if image else _join_paths(configuration.ea4all_images,'multi-app-architecture.png')
+
+    image = getattr(state,'image', None)
+    if image:
+        raw_image = state.image #['image_url']['url'].split(',')[1]
+    else:
+        raw_image = _join_paths(configuration.ea4all_images,'multi-app-architecture.png')
+
+    return Command(
+        update={
+            "messages": messages,
+            "question": state.question, #messages[-1].content,
+            "image": raw_image
+        },
+        goto='safeguard_check',
+    )
+
+    return {
+        "messages": state.messages,
+        "question": messages[-1].content,
+        "image": raw_image,
+    }
+
+async def choose_next(state: OverallState):
+    """Choose the next node based on the safety status."""
+    isArcihitectureImage = getattr(state, 'safety_status', {}).get('isArchitectureImage', False)
+    isSafe = getattr(state, 'safety_status', {}).get('isSafe', False)
+
+    return "diagram_supervisor" if isArcihitectureImage and isSafe else "final"
+
+def build_vqa_graph():
+    model = get_llm_client(BaseConfiguration.supervisor_model, api_base_url="", streaming=BaseConfiguration.streaming)
+    teams_supervisor_node = make_supervisor_node(model, ['diagram_description', 'diagram_object', 'diagram_improvement', 'diagram_risk'])
+
+    workflow = StateGraph(OverallState, input=InputState, output=OutputState,config_schema=AgentConfiguration) #input=InputState
+
+    #Setup Graph nodes
+    #Node name CANNOT have blank space - pattern: \'^[a-zA-Z0-9_-]+$\'.", \'type\'
+    workflow.add_node("start", enter_graph)
+    workflow.add_node("safeguard_check", safeguard_check)
+    workflow.add_node("diagram_supervisor", teams_supervisor_node)
+    workflow.add_node("final", call_finish)
+
+    tool_node = ToolNode([vqa_diagram])
+    workflow.add_node("tools", tool_node)
+
+    #Setup graph edges
+    #Graph entry point
+    workflow.add_edge(START, "start")
+    workflow.add_edge("start", "safeguard_check")
+    
+    workflow.add_conditional_edges(
+        "safeguard_check",
+        choose_next,
+        {
+            "diagram_supervisor": "diagram_supervisor",
+            "final": "final",
+        }
+    )
+
+    workflow.add_conditional_edges(
+        "diagram_supervisor",
+        tools_condition, 
+        #calls one of our tools. END causes the graph to terminate (and respond to the user)
+        {
+            "tools": "tools", 
+            END: END,
+        }
+    )
+
+    workflow.add_edge("final", END)
+    workflow.add_edge("tools", END)
+
+    #memory = MemorySaver()
+    diagram_graph = workflow.compile() #checkpointer=memory)
+    diagram_graph.name = "DiagramGraph"
+
+    return diagram_graph
+
+diagram_graph = build_vqa_graph()

ea4all/src/ea4all_vqa/state.py

@@ -0,0 +1,64 @@
+"""State management for the VQA graph.
+
+This module defines the state structures used in the VQA graph. It includes
+definitions for agent state, input state.
+"""
+
+import operator
+from dataclasses import dataclass
+from typing import (
+    Optional,
+    Annotated, 
+    Sequence,
+)
+
+from langchain_core.messages import (
+    BaseMessage,
+)
+from langgraph.graph import MessagesState
+
+# Optional, the InputState is a restricted version of the State that is used to
+# define a narrower interface to the outside world vs. what is maintained
+# internally.
+@dataclass(kw_only=True)
+class InputState:
+    """Represents the input state for the agent.
+
+    This class defines the structure of the input state, which includes
+    the messages exchanged between the user and the agent. It serves as
+    a restricted version of the full State, providing a narrower interface
+    to the outside world compared to what is maintained internally.
+    """
+
+    """Attributes:
+        question: user question
+        image: architecture diagram
+    """
+    question: str
+    image: str
+
+# The index state defines the simple IO for the single-node index graph
+@dataclass(kw_only=True)
+class OutputState:
+    """Represents the output schema for the Diagram agent.
+    """
+
+    messages: Optional[Annotated[Sequence[MessagesState], operator.add]] = None
+    safety_status: Optional[dict[str,str]] = None
+
+    """Attributes:
+    safety_status: safety status of the diagram provided by the user
+    Answer to user's question about the Architectural Diagram.
+    """
+
+@dataclass(kw_only=True)
+class OverallState(InputState, OutputState):
+    """Represents the overall state of the Diagram graph."""
+
+    """Attributes:
+    error: tool error
+    next: next tool to be called
+    """
+    
+    error: Optional[str] = None
+    next: Optional[str] = None

ea4all/src/graph.py

@@ -0,0 +1,254 @@
+"""Main file for constructing the EA4ALL hierarchical graph"""
+
+"""
+EA4ALL Hierarchical Graph
+This module defines the main file for constructing the EA4ALL hierarchical graph. It contains functions and classes for creating and managing the graph structure.
+Functions:
+- make_supervisor_node: Creates a supervisor node for managing a conversation between architect workers.
+- call_landscape_agentic: Calls the landscape agentic graph.
+- call_diagram_agentic: Calls the diagram agentic graph.
+- call_togaf_agentic: Calls the togaf agentic graph.
+- websearch: Search for real-time data to answer user's question
+Classes:
+- Router: TypedDict representing the worker to route to next.
+Attributes:
+- model: The LLM client for the supervisor model.
+- super_builder: The StateGraph builder for constructing the graph.
+- super_graph: The compiled EA4ALL Agentic Workflow Graph.
+Note: This module depends on other modules and packages such as langchain_core, langgraph, shared, ea4all_apm, ea4all_vqa, and ea4all_gra.
+"""
+
+"""Changelog:
+- lanchain_openapi: 0.2.9 (0.3.6 issue with max_tokens for HF models)
+#2025-06-03
+- Refactored code to fix problems with linter and type checking (Standard mode)
+"""
+
+from langgraph.types import Command
+from langchain_core.messages import (
+    HumanMessage,
+    AIMessage
+)
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.runnables import RunnableConfig
+
+from langchain import hub
+
+from langgraph.graph import (
+    START, 
+    END,
+    StateGraph,
+)
+from langgraph.checkpoint.memory import MemorySaver
+
+from typing_extensions import Literal, TypedDict
+import uuid
+
+from ea4all.src.shared.configuration import BaseConfiguration
+from ea4all.src.shared.utils import get_llm_client
+from ea4all.src.shared.state import State
+from ea4all.src.tools.tools import websearch
+
+from ea4all.src.ea4all_indexer.graph import indexer_graph
+from ea4all.src.ea4all_apm.graph import apm_graph
+from ea4all.src.ea4all_vqa.graph import diagram_graph
+from ea4all.src.ea4all_gra.graph import togaf_graph
+
+async def call_indexer_apm(state: State, config: RunnableConfig):
+    response = await indexer_graph.ainvoke(input={"docs":[]}, config=config)
+
+def make_supervisor_node(model: BaseChatModel, members: list[str]):
+    options = ["FINISH"] + members
+    
+    system_prompt = hub.pull("ea4all_super_graph").template
+
+    class Router(TypedDict):
+        """Worker to route to next. If no workers needed, route to FINISH."""
+        next: Literal["FINISH", "portfolio_team", "diagram_team", "blueprint_team", "websearch_team"]
+
+    async def supervisor_node(state: State, config: RunnableConfig) -> Command[Literal["portfolio_team", "diagram_team", "blueprint_team", "websearch_team", '__end__']]:
+
+        """An LLM-based router."""
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ] + [state["messages"][-1]]
+        
+        response = await model.with_structured_output(Router).ainvoke(messages, config=config)
+        
+        _goto = "__end__"
+        
+        if isinstance(response, dict):
+            _goto = response["next"]
+            # Ensure _goto is one of the allowed Literal values
+            if _goto not in ["portfolio_team", "diagram_team", "blueprint_team", "websearch_team"]:
+                _goto = "__end__"
+
+        print(f"---Supervisor got a request--- Question: {state['messages'][-1].content} ==> Routing to {_goto}\n")
+
+        return Command(
+                #update={"next": _goto}, 
+                goto=_goto
+                )
+
+    return supervisor_node
+
+async def call_landscape_agentic(state: State, config: RunnableConfig) -> Command[Literal['__end__']]: ##2025-02-21: NOT passing CHAT MEMORY to the APM_graph
+    response = await apm_graph.ainvoke({"question": state["messages"][-1].content}, config=config)
+    return Command(
+        update={
+            "messages": [
+                AIMessage(
+                    content=str(response), name="landscape_agentic"
+                )
+            ]
+        },
+        goto="__end__",
+    )
+
+async def call_diagram_agentic(state: State, config: RunnableConfig) -> Command[Literal['__end__']]: #NOT passing CHAT MEMORY to the Diagram_graph
+     
+    inputs = {
+        "messages": [{"role": "user", "content": state.get('messages')[-1].content}],
+        "question": state['messages'][-1].content, "image":""
+    } #user response
+
+    response = await diagram_graph.ainvoke(
+        input=inputs,
+        config=config
+    )
+
+    return Command(
+        update={
+            "messages": [
+                AIMessage(
+                    content=response['messages'][-1].content, name="landscape_agentic"
+                )
+            ]
+        },
+        goto="__end__",
+    )
+
+async def call_togaf_agentic(state: State, config: RunnableConfig) -> Command[Literal["__end__"]]: #NOT passing CHAT MEMORY to the Togaf_graph
+    print(f"---TOGAF ROUTE team node ready to --- CALL_TOGAF_AGENTIC Routing to {state['next']} with User Question: {state['messages'][-1].content}")
+
+    inputs = {"messages": [{"role": "user", "content": state.get('messages')[-1].content}]} #user response
+
+    response = await togaf_graph.ainvoke(
+        input=inputs, 
+        config=config
+    ) #astream not loading the graph
+
+    return Command(
+        update={
+            "messages": [
+                AIMessage(
+                    content=response["messages"][-1].content, name="togaf_route"
+                )
+            ]
+        },
+        goto="__end__",
+    )
+
+# Wrap-up websearch answer to user's question
+async def call_generate_websearch(state:State, config: RunnableConfig) -> Command[Literal["__end__"]]:
+    from ea4all.src.ea4all_apm.state import OverallState
+
+    if config is not None:
+        source = config.get('metadata', {}).get('langgraph_node', 'unknown')
+
+    # Invoke GENERATOR node in the APMGraph
+    state_dict = {
+        "documents": state['messages'][-1].content,
+        "web_search": "Yes",
+        "question": state['messages'][-2].content,
+        "source": source
+    }
+
+    apm_state = OverallState(**state_dict)
+    generation = await apm_graph.nodes["generate"].ainvoke(apm_state, config)
+
+    return Command(
+        update={
+            "messages": [
+                AIMessage(
+                    content=generation['generation'], name="generate_websearch"
+                )
+            ]
+        },
+        goto="__end__",
+    )
+
+async def blueprint_team(state: State) -> Command[Literal["togaf_route"]]:
+    print("---Blueprint team got a request--- Routing to TOGAF_ROUTE node")
+
+    return Command(update={**state}, goto="togaf_route")
+
+async def diagram_team(state: State) -> Command[Literal["diagram_route"]]:
+    print("---Diagram team got a request--- Routing to DIAGRAM_ROUTE node")
+
+    return Command(update={**state}, goto="diagram_route")
+
+async def super_graph_entry_point(state: State):
+    # Generate a unique thread ID
+    thread_config = RunnableConfig({"configurable": {"thread_id": str(uuid.uuid4())}})
+    
+    # Initialize state if not provided
+    if state is None:
+        state = {
+            "messages": [
+                ("system", "You are a helpful assistant"),
+                ("human", "Start the workflow")
+            ]
+        }
+    
+    # Build and compile the graph
+    graph = build_super_graph()
+    
+    # Async invocation
+    try:
+        # Use ainvoke for async execution
+        result = await graph.ainvoke(state, config=RunnableConfig(thread_config))
+        return result
+    except Exception as e:
+        print(f"Graph execution error: {e}")
+        raise
+
+# Define & build the graph.
+def build_super_graph():
+    
+    model = get_llm_client(BaseConfiguration.supervisor_model, api_base_url="", streaming=BaseConfiguration.streaming)
+    teams_supervisor_node = make_supervisor_node(model, ["portfolio_team", "diagram_team", "blueprint_team","websearch_team"])
+
+    super_builder = StateGraph(State, config_schema=BaseConfiguration)
+   
+    super_builder.add_node("apm_indexer", call_indexer_apm)
+    super_builder.add_node("supervisor", teams_supervisor_node)
+    super_builder.add_node("portfolio_team", call_landscape_agentic)
+    super_builder.add_node("websearch_team", websearch)
+    super_builder.add_node("diagram_team", diagram_team)
+    super_builder.add_node("blueprint_team", blueprint_team)
+    super_builder.add_node("generate_websearch", call_generate_websearch)
+    super_builder.add_node("diagram_route", call_diagram_agentic)
+    super_builder.add_node("togaf_route", call_togaf_agentic)
+
+
+    super_builder.add_edge(START, "apm_indexer")
+    super_builder.add_edge("apm_indexer", "supervisor")
+
+    super_builder.add_edge("websearch_team", "generate_websearch")
+    super_builder.add_edge("blueprint_team", "togaf_route")
+    super_builder.add_edge("diagram_team", "diagram_route")
+
+    super_builder.add_edge("portfolio_team", END)
+    super_builder.add_edge("generate_websearch", END)
+    super_builder.add_edge("togaf_route", END)
+    super_builder.add_edge("diagram_route", END)
+
+    #memory = MemorySaver() #With LangGraph API, inMemmory is handled directly by the platform
+    super_graph = super_builder.compile() #checkpointer=memory)
+    super_graph.name = "EA4ALL Agentic Workflow Graph"
+
+    return super_graph
+
+# Export the graph for LangGraph Dev/Studio
+super_graph = build_super_graph()

ea4all/src/shared/__init__.py

@@ -0,0 +1 @@
+"""Shared utilities module."""

ea4all/src/shared/configuration.py

@@ -0,0 +1,165 @@
+"""Define the configurable parameters for the agent."""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field, fields
+from typing import Annotated, Any, Optional, Type, TypeVar, Literal
+
+from langchain_core.runnables import RunnableConfig, ensure_config
+
+# This file contains sample APPLICATIONS to index
+DEFAULT_APM_CATALOGUE = "APM-ea4all (test-split).xlsx"
+
+# These files contains sample QUESTIONS
+APM_MOCK_QNA = "apm_qna_mock.txt"
+PMO_MOCK_QNA = "pmo_qna_mock.txt"
+
+@dataclass(kw_only=True)
+class BaseConfiguration:
+    """Configuration class for all Agents.
+
+    This class defines the parameters needed for configuring the indexing and
+    retrieval processes, including embedding model selection, retriever provider choice, and search parameters.
+    """
+
+    supervisor_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="gpt-4o-mini",
+        metadata={
+            "description": "The language model used for supervisor agents. Should be in the form: provider/model-name."
+        },
+    )
+
+    api_base_url: Annotated[str, {"__template_metadata__": {"kind": "hosting"}}] = field(
+        default="https://api-inference.huggingface.co/models/",
+        metadata={
+            "description": "The base url for models hosted on Hugging Face's model hub."
+        },
+    )
+
+    max_tokens: Annotated[int, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default=4096,
+        metadata={
+            "description": "The maximum number of tokens allowed for in general question and answer model."
+        },
+    )
+
+    temperature: Annotated[int, {"__template_metadata__": {"kind": "llm"}}] = field(
+            default=0,
+            metadata={
+                "description": "The default tempature to infere the LLM."
+            },
+        )
+
+    streaming: Annotated[bool, {"__template_metadata__": {"kind": "llm"}}] = field(
+            default=True,
+            metadata={
+                "description": "Default streaming mode."
+            },
+        )
+
+    ea4all_images: str = field(
+        default="ea4all/images",
+        metadata={
+            "description": "Configuration for the EA4ALL images folder."
+        },
+    )
+
+    ea4all_store: Annotated[str, {"__template_metadata__": {"kind": "infra"}}] = field(
+        default="ea4all/ea4all_store",
+        metadata={
+            "description": "The EA4ALL folder for mock & demo content."
+        },
+    )
+
+    ea4all_ask_human: Annotated[str, {"__template_metadata__": {"kind": "integration"}}] = field(
+        default="interrupt", #"Frontend"
+        metadata={
+            "description": "Trigger EA4ALL ask human input via interruption or receive from external frontend."
+        },
+    )
+
+    ea4all_recursion_limit: Annotated[int, {"__template_metadata__": {"kind": "graph"}}] = field(
+        default=25,
+        metadata={
+            "description": "Maximum recursion allowed for EA4ALL graphs."
+        },
+    )
+
+    # models
+    embedding_model: Annotated[str, {"__template_metadata__": {"kind": "embeddings"}}] = field(
+        default="openai/text-embedding-3-small",
+        metadata={
+            "description": "Name of the embedding model to use. Must be a valid embedding model name."
+        },
+    )
+
+    retriever_provider: Annotated[
+        Literal["faiss"],
+        {"__template_metadata__": {"kind": "retriever"}},
+    ] = field(
+        default="faiss",
+        metadata={
+            "description": "The vector store provider to use for retrieval. Options are 'FAISS' at moment only."
+        },
+    )
+
+    apm_faiss: Annotated[str, {"__template_metadata__": {"kind": "infra"}}] = field(
+        default="apm_faiss_index",
+        metadata={
+            "description": "The EA4ALL APM default Vectorstore index name."
+        },
+    )
+
+    apm_catalogue: str = field(
+        default=DEFAULT_APM_CATALOGUE,
+        metadata={
+            "description": "The EA4ALL APM default Vectorstore index name."
+        },
+    )
+
+    search_kwargs: Annotated[str, {"__template_metadata__": {"kind": "retriever"}}] = field(
+        #default="{'k': 50, 'score_threshold': 0.8, 'filter': {'namespace':'ea4all_agent'}}",
+        default="{'k':10, 'fetch_k':50}",
+        metadata={
+            "description": "Additional keyword arguments to pass to the search function of the retriever."
+        }
+    )
+
+    def __post_init__(self):
+        # Convert search_kwargs from string to dictionary
+        try:
+            if isinstance(self.search_kwargs, str):
+                self.search_kwargs = ast.literal_eval(self.search_kwargs)
+        except (SyntaxError, ValueError):
+            # Fallback to an empty dict or log an error
+            self.search_kwargs = {}
+            print("Error parsing search_kwargs")
+    
+    @classmethod
+    def from_runnable_config(
+        cls: Type[T], config: Optional[RunnableConfig] = None
+    ) -> T:
+        """Create an IndexConfiguration instance from a RunnableConfig object.
+
+        Args:
+            cls (Type[T]): The class itself.
+            config (Optional[RunnableConfig]): The configuration object to use.
+
+        Returns:
+            T: An instance of IndexConfiguration with the specified configuration.
+        """
+        config = ensure_config(config)
+        configurable = config.get("configurable") or {}
+        _fields = {f.name for f in fields(cls) if f.init}
+
+        # Special handling for search_kwargs
+        if 'search_kwargs' in configurable and isinstance(configurable['search_kwargs'], str):
+            try:
+                configurable['search_kwargs'] = ast.literal_eval(configurable['search_kwargs'])
+            except (SyntaxError, ValueError):
+                configurable['search_kwargs'] = {}
+
+        return cls(**{k: v for k, v in configurable.items() if k in _fields})
+
+T = TypeVar("T", bound=BaseConfiguration)

ea4all/src/shared/prompts.py

@@ -0,0 +1,393 @@
+import os
+
+from langchain_core.prompts.chat import (
+    ChatPromptTemplate, 
+    HumanMessagePromptTemplate, 
+    SystemMessagePromptTemplate
+)
+
+from langchain_core.prompts import PromptTemplate, FewShotChatMessagePromptTemplate
+from langchain_core.prompts import MessagesPlaceholder, format_document
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.chains.prompt_selector import ConditionalPromptSelector
+
+from langchain_core.messages import (
+    HumanMessage,
+)
+
+from langchain_core.output_parsers import (
+    JsonOutputParser
+)
+
+from langsmith import (
+    traceable,
+)
+################################
+##COLLECTION of prompt functions
+################################
+##Llama-3.1 Prompt Format
+# Define the prompt format with special tokens
+LLAMA31_CHAT_PROMPT_FORMAT = (
+    "<|begin_of_text|>"
+    "<|start_header_id|>system<|end_header_id|>{system_message}<|eot_id|>\n"
+    "<|start_header_id|>user<|end_header_id|>{human_message}<|eot_id|>\n"
+    "<|start_header_id|>ai<|end_header_id|>{ai_message}\n"
+)
+
+LLAMA31_PROMPT_FORMAT = (
+    "<|begin_of_text|>"
+    "<|start_header_id|>system<|end_header_id|>{system_message}<|eot_id|>\n"
+    "<|start_header_id|>user<|end_header_id|>{human_message}<|eot_id|>\n"
+    "<|start_header_id|>ai<|end_header_id|>{ai_message}\n"
+)
+
+##return a prompt-template class with informed user inquiry
+def ea4all_prompt(query):
+    prompt_template = PromptTemplate(
+        input_variables=["query", "answer"],
+        template=TEMPLATE_QUERY_ANSWER)
+
+    prompt = prompt_template.format(
+        query=query,
+        answer="")
+
+    return prompt
+
+##return a chat-prompt-template class from the informed template
+def ea4all_chat_prompt(template):
+    system_message_prompt = SystemMessagePromptTemplate.from_template(template)
+    human_template = "{user_question}"
+    human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
+
+    ea4all_prompt = ChatPromptTemplate.from_messages(
+        messages=[
+            system_message_prompt, 
+##            MessagesPlaceholder(variable_name="history"),
+            human_message_prompt],
+    )
+    ea4all_prompt.output_parser=JsonOutputParser()
+    
+    return ea4all_prompt
+
+##select best prompt based on user inquiry's category
+@traceable(
+    tags={os.environ["EA4ALL_ENV"]}
+)
+def ea4ll_prompt_selector(category):
+    QUESTION_PROMPT_SELECTOR = ConditionalPromptSelector(
+        default_prompt = ea4all_chat_prompt(GENERAL_TEMPLATE),
+        conditionals=[
+            (lambda category: True if category == "Strategy" else False, ea4all_chat_prompt(STRATEGY_TEMPLATE)),
+            (lambda category: True if category == "Application" else False, ea4all_chat_prompt(APPLICATION_TEMPLATE)),
+            (lambda category: True if category == "Recommendation" else False, ea4all_chat_prompt(RECOMMENDATION_TEMPLATE)),
+            (lambda category: True if category not in ("Strategy","Application", "Recommendation") else False, ea4all_chat_prompt(GENERAL_TEMPLATE))
+        ]
+    )
+ 
+    prompt = QUESTION_PROMPT_SELECTOR.get_prompt(category)
+
+    return(prompt)
+
+
+#######################
+##COLLECTION of prompts
+#######################
+
+##Template-basic instruction + context
+TEMPLATE_CONTEXT = """You are a helpful Enterprise Architect with knowledge on enterprises IT landscapes.
+Use only the context delimited by trible backticks to answer questions. Return the answer formatted as a text paragraph.
+If you don't know the answer return I could not find the information.
+Don't make up the response.
+Context: ```{cdocs}```
+Help answer: ""
+"""
+
+##Template-basic instruction + question + answer
+TEMPLATE_QUERY_ANSWER = """You are Enterprise Architect highly knowledgable on IT landscape. \
+Answer the question that is delimited by triple backticks into a style that is bullet list. \
+If the question cannot be answered using the information provided answer with "I don't know". \
+
+Always say "thanks for asking!" at the end of the answer. 
+
+Question: ```{user_question}```
+Answer: {answer}
+"""
+
+TEMPLATE_APM_QNA_ROUTING = """application portfolio assessment, application/IT landscape rationalisation, simplification or optimisation, business capability assessment, line of business landscape, who can I talk to, assistance from architecture team."""
+
+##Template-break-into-simpler-tasks
+#https://platform.openai.com/docs/guides/prompt-engineering/strategy-split-complex-tasks-into-simpler-subtasks
+TEMPLATE_HEADER = """You are a helpful enterprise architect assistant. """
+TEMPLATE_HEADER += """Your goal is to provide accurate and detailed responses to user inquiry. """
+TEMPLATE_HEADER += """You have access to a vast amount of enterprise architecture knowledge, """
+TEMPLATE_HEADER += """and you can understand and generate language fluently. """
+TEMPLATE_HEADER += """You can assist with a wide range of architectural topics, including but not limited to """
+TEMPLATE_HEADER += """business, application, data and technology architectures. """
+TEMPLATE_HEADER += """You should always strive to promote a positive and respectful conversation. 
+"""
+
+TEMPLATE_TASKS = ""
+TEMPLATE_TASKS += """You will be provided with a user inquiry. """ 
+TEMPLATE_TASKS += """Classify the inquiry into primary category and secondary category. """
+TEMPLATE_TASKS += """Primary categories: Strategy, Application, Recommendation or General Inquiry. """
+TEMPLATE_TASKS += """Strategy secondary categories: 
+- Architecture and Technology Strategy
+- Vision
+- Architecture Principles
+"""
+TEMPLATE_TASKS += """Application secondary categories:
+- Meet business and technical need
+- Business criticality
+- Roadmap
+- Business Capability 
+- Hosting 
+"""
+TEMPLATE_TASKS += """Recommendation secondary categories:
+- Application rationalisation
+- Landscape simplification
+- Reuse existent invested application
+- Business capability with overlapping applications
+- Opportunities and innovation
+"""
+TEMPLATE_TASKS += """General inquiry:
+- Speak to an architect
+"""
+TEMPLATE_TASKS += """You may also revise the original inquiry if you think that revising \
+it will ultimately lead to a better response from the language model """
+TEMPLATE_TASKS += """Provide your output in JSON format with the keys: primary, secondary, question.
+"""
+
+#Template-break-into-specific-prompt-by-category
+strategy_template = """You will be provided with inquiry about architecture strategy. 
+Follow these steps to answer user inquiry:
+STEP 1 - Using only the context delimited by triple backticks.
+STEP 2 - Look at application with roadmap to invest.
+STEP 3 - Extract the information that is only relevant to help answer the user inquiry
+"""
+
+application_template = """You will be provided with an inquiry about application architecture. 
+Follow these steps to answer user inquiry:
+STEP 1 - Using only the context delimited by triple backticks.
+STEP 2 - Extract the information that is only relevant to help answer the user inquiry
+"""
+
+recommendation_template = """You will be provided with enterprise architecture inquiry that needs a recommendation. 
+Follow these steps to answer user inquiry:
+STEP 1 - Use only the context delimited by triple backticks.
+STEP 2 - Look at applications with low business or technical fit
+STEP 3 - Look at application with roadmap diffent to invest
+STEP 4 - Look at applicatins hosted on premise
+STEP 5 - Look at Business capability with overlapping applications
+"""
+
+general_template = """You will provided with a general inquiry about enterprise architecture IT landscape.
+Follow these steps to answer user queries:
+STEP 1 - use only the context delimited by triple backticks
+STEP 2 - Extract the information that is only relevant to help answer the user inquiry
+"""
+
+default_template = """
+FINAL STEP - Do not make up or guess ANY extra information. \
+Ask follow-up question to the user if you need further clarification to understand and answer their inquiry. \
+After a follow-up question if you still don't know the answer or don't find specific information needed to answer the user inquiry \
+return I could not find the information. \
+Ensure that the response contain all relevant context needed to interpret them -
+in other words don't extract small snippets that are missing important context.
+Format the output as top-like string formatted with the most appropriate style to make it clear, concise and user-friendly for a chatbot response.
+Here is the question: {user_question}
+Here is the context: ```{cdocs}```
+"""
+STRATEGY_TEMPLATE = TEMPLATE_HEADER + strategy_template + default_template
+APPLICATION_TEMPLATE = TEMPLATE_HEADER + application_template + default_template
+RECOMMENDATION_TEMPLATE = TEMPLATE_HEADER + recommendation_template + default_template
+GENERAL_TEMPLATE = TEMPLATE_HEADER + general_template + default_template
+
+
+###############################################
+##COLLECTION of prompts for conversation memory
+###############################################
+
+_template = """Given the following conversation and a follow up question,\
+rephrase the follow up question to be a standalone question, in its original language.\
+Chat History:
+{chat_history}
+Follow Up Input: {user_question}
+Standalone question:"""
+
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template="{page_content}")
+
+
+def _combine_documents(
+    docs, document_prompt=DEFAULT_DOCUMENT_PROMPT, document_separator="\n\n"
+    ):
+    doc_strings = [format_document(doc, document_prompt) for doc in docs]
+    
+    return document_separator.join(doc_strings)
+
+
+##################################################
+##COLLECTION of prompts - RAG query transformation
+##################################################
+## Multi Query
+# Prompt
+multiquery_template = """You are an AI Enterprise Architect language model assistant. Your task is to generate five 
+different versions of the given user question to retrieve relevant documents from a vector 
+database. By generating multiple perspectives on the user question, your goal is to help
+the user overcome some of the limitations of the distance-based similarity search. 
+Provide these alternative questions separated by newlines. Original question: {standalone_question}"""
+
+decomposition_template = """You are a helpful enterprise architect assistant that generates multiple sub-questions related to an input question. \n
+The goal is to break down the input into a set of sub-problems / sub-questions that can be answers in isolation. \n
+Generate multiple search queries related to: {user_question} \n
+Output (3 queries):"""
+
+decomposition_answer_recursevely_template = """
+Here is the question you need to answer:
+
+\n --- \n {question} \n --- \n
+
+Here is any available background question + answer pairs:
+
+\n --- \n {q_a_pairs} \n --- \n
+
+Here is additional context relevant to the question: 
+
+\n --- \n {context} \n --- \n
+
+Use the above context and any background question + answer pairs to answer the question: \n {user_question}
+"""
+
+rag_fusion_questions_template = """You are a helpful enterprise architect assistant that generates multiple search queries based on a single input query. \n
+Generate multiple search queries related to: {standalone_question} \n
+Output (4 queries):"""
+
+# Few Shot Examples
+few_shot_step_back_examples = [
+    {
+        "input": "Could the members of The Police perform lawful arrests?",
+        "output": "what can the members of The Police do?",
+    },
+    {
+        "input": "Jan Sindel was born in what country?",
+        "output": "what is Jan Sindel personal history?",
+    },
+]
+# We now transform these to example messages
+few_shot_step_back_examples_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("human", "{input}"),
+        ("ai", "{output}"),
+    ]
+)
+few_shot_prompt = FewShotChatMessagePromptTemplate(
+    input_variables=["standalone_question"],
+    example_prompt=few_shot_step_back_examples_prompt,
+    examples=few_shot_step_back_examples,
+)
+few_shot_step_back_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """You are an expert at enterprise architecture world knowledge. Your task is to step back and paraphrase a question to a more generic step-back question, which is easier to answer. Here are a few examples:""",
+        ),
+        # Few shot examples
+        few_shot_prompt,
+        # New question
+        ("user", "{standalone_question}"),
+    ]
+)
+# Response prompt 
+step_back_response_prompt_template = """You are an expert of enterprise architecture world knowledge. I am going to ask you a question. Your response should be comprehensive and not contradicted with the following context if they are relevant. Otherwise, ignore them if they are not relevant.
+
+# {normal_context}
+# {step_back_context}
+
+# Original Question: {standalone_question}
+"""
+
+# HyDE document generation
+hyde_template = """Please write an architecture scientific passage to answer the question
+Question: {standalone_question}
+Passage:"""
+
+##################################################
+##COLLECTION of prompts - Agentic Workflows
+##################################################
+#Agent system prompt
+#System prompt embedded into human prompt
+awqa_human_message = HumanMessage(content=[
+        {"type": "text", "text": "{user_question}"},
+        {"type": "text", "text": "You are a helpful AI assistant, collaborating with other assistants."},
+        {"type": "text", "text": "{system_message}"},
+        {"type": "text", "text": " Use the provided tools to progress towards answering the question."},
+        {"type": "text", "text": " You have access to the following tools: {tool_names}."},
+    ])
+
+awqa_template = ChatPromptTemplate.from_messages(
+        [
+            (
+                "human",
+                "You are a helpful AI assistant, collaborating with other assistants."
+                "{system_message}"
+                " Use the provided tools to progress towards answering the question: {user_question}"
+                " You have access to the following tools: {tool_names}."
+           ),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    )
+
+#DiagramV2T
+diagramV2T_question = "How this architecture solution meets quality standards and alignment with architectural best practices?"
+diagramV2T_template = """An image will be passed to you. Please explain how it meets quality standards and alignment with architecture best practices."""
+agent_diagram_v2t_system_message = diagramV2T_template
+
+#DiagramType
+diagram_type_question = "What is this diagram type? Is a flowchart, C4, sequence-diagram, data flow or any other?"
+diagramType_template = """An image will be passed to you. Identify the type of architecture diagram this image is.
+For example, flowchart, C4, sequence flow, data flow, or other.
+
+If a type of diagram is not identified that's fine! Just return a that is was not possible to identify the architectural diagram style in this image.
+
+Do not make up or guess ANY extra information. Only extract what exactly diagram type is the images.
+"""
+
+agent_diagram_type_system_message = diagramType_template
+
+#DiagramComponents
+diagram_component_question = "Please list all components that are part of this current solution architecture"
+diagramComponent_template = """An image will be passed to you. Extract from it all components identified in this image.
+For example, application, software, connector, relationship, user, name, microservice, middeware, container or other.
+
+If no components are identified that's fine - you don't need to extract any! Just return an empty list.
+
+Do not make up or guess ANY extra information. Only extract what exactly is in the images.
+"""
+
+agent_diagram_components_system_message = diagramComponent_template
+
+#DiagramRiskVulnerabilityMitigation
+diagram_risk_question = "What are the potential risks and vulnerabilities in this current solution architecture, and how can we mitigate them?"
+diagramRVM_template = """An image will be passed to you. Extract from it potential risks and vulnerabilities along with mitigation strategy in current solution architecture.
+
+For example, risk: SQL injection, description: application A connected to MySQL database, mitigation: Use prepared 
+statements and parameterised queries to handle user input. Also, implement input validation and sanitisation to prevent malicious input from being processed.
+
+If no risks, vulnerabilities or mitigation strategy are identified that's fine - you don't need to extract any! Just return an empty list.
+
+Do not make up or guess ANY extra information. Only extract what exactly is in the image.
+"""
+
+agent_diagram_rvm_system_message = diagramRVM_template
+
+#DiagramPatternsStandardsBestPractices
+diagram_pattern_question = "Please describe well-architected patterns, standards and best practices that can be applied to the current solution architecture."
+diagramPSBP_template = """An image will be passed to you. 
+List well-architected standards, patterns or best-practices that can be applied to the current solution architecture.
+"""
+agent_diagram_psbp_system_message = diagramPSBP_template
+
+#DiagramVisualQuestionAnswerer Prompts
+diagramVQA_question = """Please describe this diagram"""
+diagramVQA_template = """An image will be passed to you. It should be a flowchart or diagram. Please answer the user question."""
+agent_diagram_vqa_system_message = diagramVQA_template

ea4all/src/shared/state.py

@@ -0,0 +1,84 @@
+"""Shared functions for state management."""
+
+import hashlib
+import uuid
+from typing import Any, Literal, Optional, Union
+
+from langgraph.graph import MessagesState
+from langchain_core.documents import Document
+
+class State(MessagesState):
+    next: Optional[str]
+    user_feedback: Optional[str]
+
+def _generate_uuid(page_content: str) -> str:
+    """Generate a UUID for a document based on page content."""
+    md5_hash = hashlib.md5(page_content.encode()).hexdigest()
+    return str(uuid.UUID(md5_hash))
+
+def reduce_docs(
+    existing: Optional[list[Document]],
+    new: Union[
+        list[Document],
+        list[dict[str, Any]],
+        list[str],
+        str,
+        Literal["delete"],
+    ],
+) -> list[Document]:
+    """Reduce and process documents based on the input type.
+
+    This function handles various input types and converts them into a sequence of Document objects.
+    It can delete existing documents, create new ones from strings or dictionaries, or return the existing documents.
+    It also combines existing documents with the new one based on the document ID.
+
+    Args:
+        existing (Optional[Sequence[Document]]): The existing docs in the state, if any.
+        new (Union[Sequence[Document], Sequence[dict[str, Any]], Sequence[str], str, Literal["delete"]]):
+            The new input to process. Can be a sequence of Documents, dictionaries, strings, a single string,
+            or the literal "delete".
+    """
+    if new == "delete":
+        return []
+
+    existing_list = list(existing) if existing else []
+    if isinstance(new, str):
+        return existing_list + [
+            Document(page_content=new, metadata={"uuid": _generate_uuid(new)})
+        ]
+
+    new_list = []
+    if isinstance(new, list):
+        existing_ids = set(doc.metadata.get("uuid") for doc in existing_list)
+        for item in new:
+            if isinstance(item, str):
+                item_id = _generate_uuid(item)
+                new_list.append(Document(page_content=item, metadata={"uuid": item_id}))
+                existing_ids.add(item_id)
+
+            elif isinstance(item, dict):
+                metadata = item.get("metadata", {})
+                item_id = metadata.get("uuid") or _generate_uuid(
+                    item.get("page_content", "")
+                )
+
+                if item_id not in existing_ids:
+                    new_list.append(
+                        Document(**{**item, "metadata": {**metadata, "uuid": item_id}})
+                    )
+                    existing_ids.add(item_id)
+
+            elif isinstance(item, Document):
+                item_id = item.metadata.get("uuid", "")
+                if not item_id:
+                    item_id = _generate_uuid(item.page_content)
+                    new_item = item.copy(deep=True)
+                    new_item.metadata["uuid"] = item_id
+                else:
+                    new_item = item
+
+                if item_id not in existing_ids:
+                    new_list.append(new_item)
+                    existing_ids.add(item_id)
+
+    return existing_list + new_list

ea4all/src/shared/utils.py

@@ -0,0 +1,487 @@
+"""Shared utility functions used in the project.
+
+Functions:
+
+"""
+
+import os
+import datetime
+import getpass
+import base64
+import json
+import re
+from dotenv import load_dotenv, find_dotenv
+import markdown
+from markdownify import markdownify as md2text
+from io import BytesIO
+import pandas as pd
+
+from pydantic import BaseModel, SecretStr
+
+from langchain_community.vectorstores import Chroma
+from langchain import hub
+from langchain_core.prompts import PromptTemplate
+
+#Model & Index & Embeddings
+from langchain_openai import (
+    ChatOpenAI,
+)
+
+from langchain_core.output_parsers import (
+    PydanticOutputParser, 
+)
+
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    get_buffer_string,
+)
+
+from PIL import Image
+
+from ea4all.src.shared.prompts import (
+    LLAMA31_CHAT_PROMPT_FORMAT,
+)
+
+from ea4all.src.shared.configuration import BaseConfiguration as ea4all_config
+
+############
+##INIT model
+############
+#initialise model / constants
+EA4ALL_ARCHITECTURE = "ea4all_architecture.png"
+EA4ALL_PODCAST = "ea4all_podcast.wav"
+
+class CFG:
+    # Constants
+    EA4ALL_OVERVIEW = "ea4all_overview.png"
+    EA4ALL_ABOUT = "ea4all_overview.txt"
+    APM_MOCK_QNA = "apm_qna_mock.txt"
+    STREAM_SLEEP = 0.05
+    REGEX_BACKTICKS = r"```(.*?)```"
+
+    # LLMs
+    #model = {"gpt-4":'gpt-4o-mini', "gpt-4o":'gpt-4o'}
+    #llama = {"11": "meta-llama/llama-3.2-11B-Vision-Instruct", "90":"meta-llama/llama-3.2-90B-Vision-Instruct", "70":"meta-llama/Llama-3.1-70B-Instruct", "73":"meta-llama/Llama-3.3-70B-Instruct"}
+    
+    #hf_model="meta-llama/Llama-3.1-70B-Instruct"
+    #hf_api_base="https://api-inference.huggingface.co/models/"
+
+    #hf_max_tokens=16192
+    #max_new_tokens = 4096
+    #llama32_max_tokens = 4096 ##TOKEN ISSUE LLAMA-3.2 w/ ChatOpenAI not working tokens > 4096 2024-10-13
+
+    #temperature = 0
+    top_p = 0.95
+    repetition_penalty = 1.15    
+
+    # splitting
+    split_chunk_size = 500
+    split_overlap = 0
+    
+    # embeddings
+    #embeddings_model = OpenAIEmbeddings()
+
+    # similar passages
+    k = 3
+
+    #debug
+    verbose=True
+
+    #streamming
+    #streamming=True
+
+    #VQA resized images - maximum resolution for Llama-3.2
+    RESIZE_TO = 512
+    MAX_WIDTH = 1024
+    MAX_HEIGHT = 768
+
+    ##Diagrams format
+    diagram_format = "png"
+
+    # paths ea4all/src/tools
+    #apm_store = "/Users/avfranco/Documents/GitHub/ea4all-agentic-staging/ea4all/apm_store/"
+    #apm_path = apm_store + 'APM-ea4all (test-split).xlsx'
+    #dbr_demo = apm_store + "reference_architecture_dbr_demo.txt"
+
+    #'ea4all_images = "/Users/avfranco/Documents/GitHub/ea4all-agentic-staging/ea4all/images/"
+
+    #apm_faiss = "apm_store"
+    #faiss_index =  'apm_faiss_index'
+
+###################################
+##COLLECTION of re-usable functions
+###################################
+
+#return current date-time
+def _get_datetime():
+    now = datetime.datetime.now()
+    return now.strftime("%m/%d/%Y, %H:%M:%S")
+
+def _get_formatted_date():
+    current_date = datetime.datetime.now()
+    formatted_date = current_date.strftime("%d %B %Y")
+
+    return formatted_date
+
+#calculate dif end-start execution
+def time_elapsed(start,end):
+    time_elapsed = int(round(end - start, 0))
+    time_elapsed_str = f'{time_elapsed}'
+
+    return time_elapsed_str
+
+def _join_paths(*paths):
+    """
+    Join two or more paths using os.path.join.
+
+    Parameters:
+    *paths: str
+        Two or more path components to be joined.
+
+    Returns:
+    str
+        The joined path.
+    """
+    return os.path.join(*paths)
+
+#get user request info
+def get_user_identification(request):
+    if request:
+        try:
+            user_pip = request.headers.get('X-Forwarded-For')
+            return user_pip.split(',')[0]
+        except Exception:
+            print(f"user info: {request}")
+            return request.client.host
+        
+    return "ea4all_agent"
+
+#Initialise model
+## SETUP LLM CLIENT
+def get_llm_client(model, api_base_url=None,temperature=0, streaming=False, tokens=ea4all_config.max_tokens) -> ChatOpenAI:
+    """Initializes and returns a ChatOpenAI client based on the specified model and parameters."""
+    client = ChatOpenAI()
+
+    if model.startswith("gpt-"):
+       client = ChatOpenAI(
+            model=model,
+            temperature=temperature,
+            streaming=streaming,
+            max_completion_tokens=tokens,
+            stream_usage=True
+        )        
+    elif "llama" in model.lower():  # Meta-llama models
+        client = ChatOpenAI(
+            model=model,
+            api_key=SecretStr(os.environ['HUGGINGFACEHUB_API_TOKEN']),
+            base_url=_join_paths(api_base_url, model, "v1/"),
+            temperature=temperature,
+            streaming=streaming,
+            max_completion_tokens=tokens,
+            stream_usage=True,
+        )
+    
+    return client
+
+#load local env variables
+def load_local_env(local):
+    ###read local .env file
+    _ = load_dotenv(find_dotenv()) 
+    if local not in os.environ:
+        os.environ[local] = getpass.getpass(f"Provide your {local} Key")
+    return os.environ[local]
+
+#locad landscape data into chroma
+def load_to_chroma(documents, embeddings, path, collection_name="apm_collection"):
+    #Read chromadb chroma-apm-db
+    chroma_collection = Chroma (
+        collection_name=collection_name,
+        persist_directory=path,
+        embedding_function=embeddings
+        )  
+
+    if chroma_collection._collection.count():
+        chroma_collection.delete_collection()
+    else:
+        #Add apm records
+        chroma_collection = Chroma.from_documents(
+            collection_name=collection_name,
+            persist_directory=path,
+            documents=documents,
+            embedding=embeddings
+        )
+        chroma_collection.persist()
+    
+    return chroma_collection
+
+##Convert gradio chat_history to langchain chat_history_format
+def get_history_gradio(history, chat_history=[]):
+    history_langchain_format = []
+    #triggered by loaded memory runnable to replace ConversationMemoryBuffer.load_memory_variables
+    #if chat_history or not history:
+    #    memory = chat_history
+    #triggered by loaded_memory runnable
+    #else:
+    history = history["chat_memory"]
+    
+    for human, ai in history:
+        history_langchain_format.append(HumanMessage(content=human))
+        history_langchain_format.append(AIMessage(content=ai))
+ 
+    history = {"history":get_buffer_string(history_langchain_format)}
+
+    return history
+
+#retrieve relevant questions based on user interaction
+def get_vqa_examples() -> list:
+    examples=[
+        {"text": "Describe this image.", "files": ["ea4all/images/multi-app-architecture.png"]},
+        {"text": "Assess any risk and vulnerabilities in the current solution.", "files": ["ea4all/images/ea4all_architecture.png"]},
+    ]
+    return examples
+
+# Function to encode the image
+def encode_image(image_path):
+  with open(image_path, "rb") as image_file:
+    return base64.b64encode(image_file.read()).decode('utf-8')
+
+def resize_image_1(raw_image, input_size):
+    w, h = raw_image.size
+    scale = input_size / max(w, h)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+    resized_image = raw_image.resize((new_w, new_h))
+
+    return resized_image
+
+def resize_image_2(image, width):
+    wpercent = width / float(image.size[0])
+    hsize = int( float(image.size[1]) * wpercent )
+    raw_image = image.resize([width, hsize])
+
+    return raw_image
+
+def resize_image_3(image):
+    from PIL import Image
+    # Get the current size
+    width, height = image.size
+
+    # Calculate the new size maintaining the aspect ratio
+    if width > CFG.MAX_WIDTH or height > CFG.MAX_HEIGHT:
+        ratio = min(CFG.MAX_WIDTH / width, CFG.MAX_HEIGHT / height)
+        new_width = int(width * ratio)
+        new_height = int(height * ratio)
+    else:
+        new_width, new_height = width, height
+    
+    # Resize the image
+    image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    
+    # Return new resized image
+    return image
+
+#Encode PIL.Image to base64
+def encode_raw_image(raw_image):
+    # Create a BytesIO buffer
+    buffer = BytesIO()
+
+    # Save the image to the buffer in PNG format
+    raw_image.save(buffer, format='PNG')
+
+    # Get the content of the buffer
+    img_bytes = buffer.getvalue()
+
+    # Encode the bytes to base64
+    img_base64 = base64.b64encode(img_bytes)
+
+    # Convert the bytes to string
+    img_str = img_base64.decode('utf-8')
+
+    return img_str
+
+#Return a raw image ready to OpenAI GPT4-Vision
+def get_raw_image(image_path):
+    # Open & Resize & Encode image
+    diagram = Image.open(image_path)
+    w, h = diagram.size
+    if w > CFG.RESIZE_TO or h > CFG.RESIZE_TO:
+        resized_image = resize_image_3(diagram)
+    else:
+        resized_image = diagram
+
+    #Encode diagram
+    raw_image = encode_raw_image(resized_image)
+
+    return raw_image
+
+def load_mock_content(file_path) -> str:
+    try:
+        with open(_join_paths(ea4all_config.ea4all_store,file_path), "r") as file:
+            content = file.read()
+            return content
+    except ValueError as e:
+        return str(e)
+    
+def print_json_to_md(data, indent=0, column=None):
+    try:
+        result = ""
+        header = ""
+        body = ""
+        if isinstance(data, dict):
+            for key, value in data.items():
+                result  +=  print_json_to_md(value, indent + 2, key)
+            return result
+        elif isinstance(data, list):
+            if column:  # Print list items as a Markdown table
+                header = ' ' * indent + f"| {' | '.join(data[0].keys())} | \n"
+                header += ' ' * indent + f"| {' | '.join(['---'] * len(data[0]))} | \n"
+                for item in data:
+                    body += ' ' * indent + f"\n\n | {' | '.join(str(item[k]) for k in item.keys())} |"
+                result += header + body
+                return result
+            else:
+                for item in data:
+                    header = ' ' * indent + f"| {' | '.join(data[0].keys())} |"
+                    body += ' ' * indent + f"\n\n | {' | '.join(str(item[k]) for k in item.keys())} |"
+                result += header + "\n" + body
+                return result
+        else:
+            header +=  ' ' * indent + f"| {column} "
+            body += f"{str(data)}\n\n"
+            result += header + body
+            return result
+
+    except Exception as e:
+        return f"{e} - {data}"
+
+def markdown_to_plain_text(md):
+    # Convert Markdown to HTML
+    html = markdown.markdown(md)
+    # Convert HTML to plain text using markdownify
+    plain_text = md2text(html)
+    return plain_text
+
+def extract_structured_output(response):
+    ##EXTRACT Topic from the content
+    try:
+        return json.loads(response)
+    except ValueError:
+        match = re.search(CFG.REGEX_BACKTICKS, response, re.DOTALL)
+        
+        if match:
+            return json.loads(match.group(1))
+        else:
+            return None
+
+def get_predicted_num_tokens(llm, content):
+    return llm.get_num_tokens(content)
+
+def get_predicted_num_tokens_from_prompt(llm, prompt, values):
+    final_prompt = prompt.format(**values)
+    return llm.get_num_tokens(final_prompt)
+
+def set_max_new_tokens(predicted_tokens):
+    #Return max new tokens to be generated
+    return int((ea4all_config.max_tokens - predicted_tokens) * 0.95)
+
+def escape_special_characters(input_string):
+    # Use json.dumps to escape special characters
+    escaped_string = json.dumps(input_string)
+    # Remove the surrounding double quotes added by json.dumps
+    return escaped_string[1:-1]
+
+def clean_and_load_json(content) -> dict:
+    try:
+        json_data = json.loads(content)
+        return json_data
+    except ValueError:
+        clean_string = content.replace("\n","").replace("json","")
+        json_data = json.loads(clean_string)
+        return json_data
+
+def extract_response_from_backticks(response):
+    pattern = r"```(.*?)```"
+    match = re.search(pattern, str(response), re.DOTALL)
+
+    return match.group(1) if match else response  
+
+def extract_topic_from_business_input(response) -> dict:
+    ##IS JSON already
+    if isinstance(response, dict):
+        return response
+    
+    ##EXTRACT Topic from the content
+    topic = extract_response_from_backticks(response)
+    
+    return clean_and_load_json(topic)
+
+## LLM STRUCTURED OUTPUT Helper functions
+def extract_landscape(topic):
+    # Prompt
+    extract_landscape_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_landscape_business_query')
+
+    # Set up a parser: LandscapeAsIs
+    parser = PydanticOutputParser(pydantic_object=topic) 
+
+    final_prompt = extract_landscape_prompt.partial(
+        format_instructions=parser.get_format_instructions(),
+        ai_output=LLAMA31_CHAT_PROMPT_FORMAT,
+    )
+
+    return final_prompt
+
+def extract_principles(topic):
+
+    # Set up a parser: LandscapeAsIs
+    parser = PydanticOutputParser(pydantic_object=topic) 
+
+    #PROMPT REVISED TO WORK w/ Llama-3
+    principle_template = """Identify the list of principles and its meaning from the given context.
+    Do not add any superfluous information.
+    Context: \n {strategic_principles} \n
+    Output your answer as JSON that matches the given schema and nothing else: \n{format_instructions}\n
+    """
+
+    prompt = PromptTemplate(
+        template=principle_template,
+        input_variables=["strategic_principles"],
+        partial_variables={
+            "format_instructions": parser.get_format_instructions(),
+            },
+    )
+
+    return prompt
+
+# Task-1: Identify the business requirements, objectives, user journey, and all other relevant information
+def extract_detailed_business_requirements(llm, topic: type[BaseModel], name:str, values:dict):
+    parser = PydanticOutputParser(pydantic_object=topic)
+    
+    hub_prompt = hub.pull('learn-it-all-do-it-all/ea4all_extract_business_topic')
+    hub_prompt = hub_prompt.partial(
+        topic=name,
+        format_instructions=parser.get_format_instructions(),
+    )
+    
+    task_1_requirement = hub_prompt | llm | parser
+    response = task_1_requirement.invoke(
+        input=values, 
+        config={
+            'tags': ['assess_business_query'],
+            'run_name': name  # Custom run name
+        }
+    )
+
+    return response
+
+# Post-processing
+def format_docs(docs):
+    return "\n".join(doc.page_content for doc in docs)
+
+#load mock data
+def get_relevant_questions(source: str) -> list:
+    relevant_questions = []
+    mock = load_mock_content(source)
+    for line in mock.splitlines(): relevant_questions += [line]
+
+    return relevant_questions

ea4all/src/shared/vectorstore.py

@@ -0,0 +1,196 @@
+from langchain_core.runnables import RunnableConfig
+from langchain.docstore.document import Document
+from langchain_core.embeddings import Embeddings
+from langchain_core.vectorstores import VectorStoreRetriever
+
+import ast
+import numpy as np
+import pandas as pd
+from contextlib import contextmanager
+from typing import Generator
+
+from ea4all.src.shared.utils import _join_paths
+from ea4all.src.shared.configuration import BaseConfiguration
+
+global _vectorstore
+_vectorstore = None
+
+def make_text_encoder(model: str) -> Embeddings:
+    """Connect to the configured text encoder."""
+    provider, model = model.split("/", maxsplit=1)
+    match provider:
+        case "openai":
+            from langchain_openai import OpenAIEmbeddings
+
+            return OpenAIEmbeddings(model=model)
+        case _:
+            raise ValueError(f"Unsupported embedding provider: {provider}")
+
+@contextmanager
+def make_faiss_retriever(
+    configuration: BaseConfiguration, embeddings: Embeddings
+) -> Generator[VectorStoreRetriever, None, None]:
+    """Configure this agent to connect to a FAISS index & namespaces."""
+    from langchain_community.docstore.in_memory import InMemoryDocstore
+    from langchain_community.vectorstores import FAISS
+    import faiss
+
+    global _vectorstore
+
+    if _vectorstore is None:
+        try:
+            _vectorstore = FAISS.load_local(
+                folder_path=configuration.ea4all_store,
+                embeddings=embeddings,
+                index_name=configuration.apm_faiss,
+                allow_dangerous_deserialization=True)
+            
+        except Exception as e:
+            # Create an empty index
+            index = faiss.IndexFlatL2(len(embeddings.embed_query("")))
+
+            #Initialize an empty FAISS vectorstore
+            _vectorstore = FAISS(
+                embedding_function=embeddings,
+                index=index,
+                docstore=InMemoryDocstore(),
+                index_to_docstore_id={},
+            )
+            #apm_docs = get_apm_excel_content(configuration)
+            #_vectorstore = FAISS.from_documents(apm_docs, embeddings)
+            #_vectorstore.save_local(folder_path=configuration.ea4all_store, index_name=configuration.apm_faiss,)
+
+    search_kwargs  = configuration.search_kwargs
+
+    yield _vectorstore.as_retriever(search_type="similarity", search_kwargs=search_kwargs)
+
+@contextmanager
+def make_retriever(
+    config: RunnableConfig,
+) -> Generator[VectorStoreRetriever, None, None]:
+    """Create a retriever for the agent, based on the current configuration."""
+    configuration = BaseConfiguration.from_runnable_config(config)
+    embeddings = make_text_encoder(configuration.embedding_model)
+    match configuration.retriever_provider:
+        case "faiss":
+            with make_faiss_retriever(configuration, embeddings) as retriever:
+                yield retriever
+
+        case _:
+            raise ValueError(
+                "Unrecognized retriever_provider in configuration. "
+                f"Expected one of: {', '.join(BaseConfiguration.__annotations__['retriever_provider'].__args__)}\n"
+                f"Got: {configuration.retriever_provider}"
+            )
+
+#convert dataframe to langchain document structure, added user_ip
+def panda_to_langchain_document(dataframe,user_ip):
+    # create an empty list to store the documents
+    apm_documents = []
+    # iterate over the rows of the dataframe
+    for index, row in dataframe.iterrows():
+        # create a document object from the row values for all df columns
+        page_content = ""
+        application = ""
+        capability = ""
+        description = ""
+        fit = ""
+        roadmap = ""
+        for column in dataframe.columns:
+            column = ' '.join(column.split())
+            page_content += f" {column}:{row[column]}"
+            if 'application' in column.lower(): application = row[column]
+            elif 'capabilit' in column.lower(): capability = row[column]
+            elif 'desc' in column.lower(): description = row[column]
+            elif 'business fit' in column.lower(): fit = row[column]
+            elif 'roadmap' in column.lower(): roadmap = row[column]
+        doc = Document(
+            page_content=page_content, 
+            metadata={
+                "source": application, 
+                "capability": capability,
+                "description": description,
+                "business fit": fit,
+                "roadmap": roadmap,
+                "row_number": index, "namespace": user_ip}
+            )
+        # append the document object to the list
+        apm_documents.append(doc)
+    return(apm_documents)
+
+#local landscape data (excel file)
+def apm_dataframe_loader(file):
+    pd.set_option('display.max_colwidth', None)
+    df = pd.read_excel(file)
+    df = df.dropna(axis=0, how='all')
+    df = df.dropna(axis=1, how='all')
+    df.fillna('NaN')
+
+    return df
+
+##New APM Excel loader
+#Removed df from return
+def get_apm_excel_content(config:RunnableConfig, file=None, user_ip="ea4all_agent"):
+
+    if file is None:
+        file = _join_paths(
+            getattr(config, "ea4all_store", BaseConfiguration.ea4all_store),
+            getattr(config, "apm_catalogue", BaseConfiguration.apm_catalogue)
+        )
+
+    #load file into dataframe
+    df = apm_dataframe_loader(file)
+    #add user_id into df
+    df['namespace'] = user_ip
+
+    apm_docs = panda_to_langchain_document(df, user_ip)
+    return apm_docs
+
+def remove_user_apm_faiss(config, db, ea4all_user):
+    #apm_vectorstore.docstore.__dict__["_dict"][apm_vectorstore.index_to_docstore_id[0]].metadata
+
+    #check if user's uploaded any apm before
+    byod = ea4all_user in str(db.docstore._dict.values())
+
+    #if yes
+    if byod:
+        removed_ids = []
+        for id, doc in db.docstore._dict.items():
+            if doc.metadata['namespace'] == ea4all_user:
+                removed_ids.append(id)
+        
+        ##save updated index
+        if removed_ids:
+            index_ids = [
+                i_id
+                for i_id, d_id in db.index_to_docstore_id.items()
+                if d_id in removed_ids
+                ]
+            #Remove ids from docstore
+            db.delete(ids=removed_ids) 
+            #Remove the corresponding embeddings from the FAISS index
+            db.index.remove_ids(np.array(index_ids,dtype=np.int64))
+            #Reorg embeddings
+            db.index_to_docstore_id = {
+                i: d_id
+                for i, d_id in enumerate(db.index_to_docstore_id.values())
+                }
+            #save updated index
+            db.save_local(folder_path=config.ea4all_store, index_name=config.apm_faiss)
+
+#Get faiss index as a retriever
+def retriever_faiss(db, user_ip="ea4all_agent"):
+    ##size: len(retriever.vectorstore.index_to_docstore_id), retriever.vectorstore.index.ntotal
+
+    #check if user's BYOData
+    byod = user_ip in str(db.docstore._dict.values())
+    
+    if byod==False: 
+        namespace="ea4all_agent"
+    else:
+        namespace = user_ip
+
+    retriever = db.as_retriever(search_type="similarity", 
+        search_kwargs={'k': 50, 'score_threshold': 0.8, 'filter': {'namespace':namespace}})
+
+    return retriever

ea4all/src/tools/tools.py

@@ -0,0 +1,111 @@
+from typing import Literal, Annotated
+from typing_extensions import TypedDict
+import json
+import tempfile
+import os
+
+from langchain_core.runnables import RunnableLambda, RunnableConfig
+
+from langgraph.graph import END
+from langgraph.types import Command
+from langgraph.prebuilt import InjectedState
+
+from langchain_community.utilities import BingSearchAPIWrapper
+from langchain_community.tools.bing_search.tool import BingSearchResults
+from langchain_community.document_loaders import JSONLoader
+
+from langchain.agents import tool
+
+from ea4all.src.shared.configuration import (
+    BaseConfiguration
+)
+
+from ea4all.src.shared.state import (
+    State
+    )
+
+from ea4all.src.shared.utils import (
+    get_llm_client,
+    format_docs,
+)
+
+def make_supervisor_node(config: RunnableConfig, members: list[str]) -> RunnableLambda:
+    options = ["FINISH"] + members
+    system_prompt = (
+        "You are a supervisor tasked with managing a conversation between the"
+        f" following workers: {members}. Given the following user request,"
+        " respond with the worker to act next. Each worker will perform a"
+        " task and respond with their results and status. When finished,"
+        " respond with FINISH."
+    )
+
+    configuration = BaseConfiguration.from_runnable_config(config)
+    model = get_llm_client(
+        configuration.supervisor_model, 
+        api_base_url="",
+    )
+
+    class Router(TypedDict):
+        """Worker to route to next. If no workers needed, route to FINISH."""
+
+        next: Literal[*options]
+
+    def supervisor_node(state: State) -> Command[Literal[*members, "__end__"]]:
+        """An LLM-based router."""
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ] + state["messages"]
+        response = model.with_structured_output(Router).invoke(messages)
+        goto = response["next"]
+        if goto == "FINISH":
+            goto = END
+
+        return Command(goto=goto, update={"next": goto})
+
+    return RunnableLambda(supervisor_node)
+
+async def websearch(state: dict[str, dict | str]) -> dict[str,dict[str,str]]:
+    """
+    Web search based on the re-phrased question.
+
+    Args:
+        state (dict): The current graph state
+        config (RunnableConfig): Configuration with the model used for query analysis.
+
+    Returns:
+        state (dict): Updates documents key with appended web results
+    """
+
+    ##API Wrapper
+    bing_subscription_key = os.environ.get("BING_SUBSCRIPTION_KEY", "")
+    bing_search_url = os.environ.get("BING_SEARCH_URL", "https://api.bing.microsoft.com/v7.0/search")
+    search = BingSearchAPIWrapper(
+        bing_subscription_key=bing_subscription_key,
+        bing_search_url=bing_search_url
+    )
+
+    question = getattr(state,'messages')[-1].content if getattr(state,'messages', False) else getattr(state,'question')
+
+    ##Bing Search Results
+    web_results = BingSearchResults(
+        api_wrapper=search,
+        handle_tool_error=True,
+        args_schema={"k":"5"}, 
+    )
+    
+    result = await web_results.ainvoke({"query": question})
+
+    fixed_string = result.replace("'", "\"")
+    result_json = json.loads(fixed_string)
+
+    # Create a temporary file
+    with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
+        # Write the JSON data to the temporary file
+        json.dump(result_json, temp_file)
+        temp_file.flush()
+
+        # Load the JSON data from the temporary file
+        loader = JSONLoader(file_path=temp_file.name, jq_schema=".[]", text_content=False)
+        docs = loader.load()
+
+    return {"messages": {"role":"assistant", "content":format_docs(docs)}}

ea4all/utils/utils.py

@@ -0,0 +1,182 @@
+import ea4all.src.ea4all_apm.graph as e4a
+import ea4all.src.ea4all_vqa.graph as e4v
+import ea4all.src.ea4all_gra.graph as e4t
+import ea4all.src.shared.utils as e4u
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration as gra
+from ea4all.src.shared import vectorstore
+from ea4all.src.shared.configuration import BaseConfiguration
+from ea4all.src.ea4all_indexer.configuration import IndexConfiguration
+from ea4all.src.ea4all_indexer.graph import indexer_graph
+
+from langchain_community.document_loaders import ConfluenceLoader
+from langchain_core.messages import ChatMessage
+from langsmith import Client
+
+import uuid
+import os
+import time
+import pandas as pd
+import gradio as gr
+
+class UIUtils:
+    #ea4all-about
+    @staticmethod
+    def ea4all_about(show_api=False):
+        readme = e4u.load_mock_content(e4u.CFG.EA4ALL_ABOUT)
+        return readme
+
+    #vqa_chatbot (ChatInterface -> Chatbot)
+    @staticmethod
+    def add_message(message, history):
+        if message["text"] is not None:
+            history.append({"role": "user", "content": message["text"]})
+        
+        if len(message['files']) > 0:
+            history.append({"role": "user", "content": {"path": message['files'][-1]}})
+        
+        return (
+            gr.MultimodalTextbox(value=message, interactive=True, placeholder="Upload a diagram and type your message..."),
+            history
+        )
+
+    #Upload & clear business requirement
+    @staticmethod
+    def load_dbr(file):
+        return file.decode()
+
+#Load demo business requirements
+def init_dbr():
+    # Open the file in read mode ('r')
+    with open(e4u._join_paths(BaseConfiguration.ea4all_store, gra.dbr_mock), 'r') as file:
+        # Read the contents of the file
+        contents = file.read()
+    return contents
+
+def init_df(show_api=False):
+    return vectorstore.apm_dataframe_loader(e4u._join_paths(BaseConfiguration.ea4all_store, IndexConfiguration.apm_catalogue))
+
+#load core-architecture image
+#fix the issue with gr.Image(path) inside a docker containder
+def get_image(_image):
+    #from PIL import Image
+    # Load an image
+    image = e4u._join_paths(BaseConfiguration.ea4all_images,_image)
+    print(f"Full path: {image}")
+
+    return image
+
+def ea4all_confluence(show_api=False):
+
+    #Confluence API Key
+    confluence_api_key = os.environ['CONFLUENCE_API_KEY']
+
+    loader = ConfluenceLoader(
+        url="https://learnitall.atlassian.net/wiki", username="[email protected]", api_key=confluence_api_key,
+        space_key="~71202000cd55f36336455f8c07afa1860ba810", 
+        include_attachments=False, limit=10,
+        keep_markdown_format=True
+    )
+
+    documents = loader.load()
+
+    data = {
+            "title": [doc.metadata["title"] for doc in documents],
+            "source": [doc.metadata["source"] for doc in documents],
+            "page_content": [doc.page_content for doc in documents],
+        }
+
+    df = pd.DataFrame(data)
+
+    return df        
+
+def filter_page(page_list, title):
+    x =  page_list[page_list["title"] == title]
+    return x.iloc[0]['page_content']
+
+#get LLM response user's feedback
+def get_user_feedback(evt: gr.SelectData, request:gr.Request):
+    ##{evt.index} {evt.value} {evt._data['liked']}
+    try:     
+        uuid_str = os.environ["EA4ALL_" + e4u.get_user_identification(request).replace(".","_")]
+        gr.Info("Thanks for your feedback - run_id: " + uuid_str)
+        run_id = uuid.UUID(uuid_str)
+        client = Client()
+        client.create_feedback(
+            run_id,
+            key="feedback-key",
+            score= 1.0 if evt._data['liked'] == True else 0,
+            comment=str(evt.value)
+        )
+    except Exception as e:
+        gr.Warning(f"Couldn't capture a feedback: {e}")
+
+#Set initial state of apm, llm and capture user-ip
+async def ea4all_agent_init(request:gr.Request):
+
+    agentic_qna_desc="""Hi,
+        improve effieciency, knowledge sharing, and get valuable insights from your IT landscape using natural language.
+        As an Enterprise Architect Agentic Companion I can answer questions related to Enterprise Architecture, Technology, plus the following IT Landscape sample dataset: """
+
+    #capture user IP address
+    #ea4all_user = e4u.get_user_identification(request)
+    gr.Info("Thank you for using the EA4ALL Agentic MCP Server!")
+
+    # Set initial landscape vectorstore
+
+    #await indexer_graph.ainvoke(input={"docs":[]}, config=config)
+
+    #set chatbot description w/ user apm columns
+    df = vectorstore.apm_dataframe_loader(e4u._join_paths(BaseConfiguration.ea4all_store, IndexConfiguration.apm_catalogue))
+    columns_string = ', '.join(df.columns)
+    apm_columns = agentic_qna_desc + columns_string
+
+    prompt=ChatMessage(role='assistant', content='Hi, I am your Architect Copilot! How can I help you today?')
+
+    page_list = ea4all_confluence()
+
+    #Load gradio.dataframe with Portfolio sample dataset
+    pmo_df = pd.read_csv("ea4all/ea4all_store/ea4all-portfolio-management.csv")
+
+    dbr_text = init_dbr()
+
+    return (
+        apm_columns, 
+        [{"role": "system", "content": "You are a helpful assistant."}],
+        [{"role": "system", "content": "You are a helpful assistant."}],
+        [{"role": "system", "content": "You are a helpful assistant."}],
+        gr.DataFrame(value=df),
+        gr.DataFrame(value=pmo_df),
+        dbr_text
+    )
+
+#authentication
+def ea4all_login(username, password):
+    return (username==password)
+
+#TABS & Reference Architecture look-and-feel control
+def off_dbrtext():
+    return gr.TextArea(visible=False), gr.Tab(visible=False), gr.Tab(visible=False)
+
+def on_dbrtext(file):
+    if file:
+        return gr.TextArea(visible=True)
+    return gr.TextArea(visible=False)
+
+def unload_dbr():
+    return gr.TextArea(visible=False)
+
+def get_question_diagram_from_example(value) -> list:
+    """
+    Extracts the question and diagram from the selected example.
+    """
+    if value:
+        return [value['text'], value['files'][-1]] if 'files' in value else [value['text'], None]
+    return ["", None]
+
+def on_image_update(image: gr.Image) -> gr.Image:
+    """
+    Callback to handle image updates.
+    """
+    visible = True if image is not None else False
+
+    return gr.Image(visible=visible)