ea4all-gradio-agents-mcp-hackathon-kickoff

.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/

README.md

@@ -11,4 +11,110 @@ license: apache-2.0
 short_description: Enterprise Architecture Agentic system exposed as Gradio MCP
 ---
 
-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

@@ -1,7 +1,33 @@
-import gradio as gr
+#import gradio as gr
 
-def greet(name):
-    return "Hello " + name + "!!"
+#def greet(name):
+#    return "Hello " + name + "!!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+#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/__main__.py

@@ -0,0 +1,18 @@
+from ea4all import app_ea4all_agent.ea4all_agentUI as ea4all_mcp
+import os
+
+def main() -> None:
+    #Launch UI
+    try:
+        ea4all_mcp.launch(
+            server_name=os.getenv("GRADIO_SERVER_NAME","0.0.0.0"),
+            server_port=os.getenv("GRADIO_SERVER_PORT",None),
+            debug=os.getenv("GRADIO_DEBUG",True),
+            ssr_mode=False,
+            mcp_server=True,
+        )
+    except Exception as e:
+        print(f"Error loading: {e}")
+    
+if __name__ == "__main__":
+    main()

ea4all/app_ea4all_agent.py

@@ -0,0 +1,655 @@
+#Added agentic-workflow-collaboration-agents
+#Multimodal ChatInterface - not working
+#Added new QA Tab
+#Added new agent Well-Architected
+#Added Supervisor Agent workflow
+#ISSUE with VQA fixed
+#LLMChain refactored
+#Updated with changes as result of ea4all_agent Gradio Space deployment issues 
+#VQA Safeguardings - JPEG, PNG images only
+#Deployed version to Live
+#Library import refactoring, ea4all-architecture, empty message
+#Bring your own IT Landscape data: discontinued 
+#Added upload your Business Requirement
+#Load user's APM - disabled 2024-06-22
+#TEST E2E Togaf Agentic system 2024-06-24
+#MIGRATION TO HF Open Source using TGI and Meta-Llama-3-8B-Instruct 2024-06-25
+#ADDED GENERATE_ARCHITECTURE_RUNWAY diagram: graphviz 2024-07-03
+#REFERENCE ARCHITECTURE DYNAMIC TABS 2024-07-05
+#ADDED Business Query grader 2024-07-07
+#RCA Togaf Supervisor: increase reliability 2024-07-08 - ISSUE FIXED BY NOW
+#EA4ALL-agentic-system-container updated 2024-07-10
+###APM Agentic system: 2024-07-25 - Safety check added
+##Sub-graph node stream 204-07-26
+# Stream arbitrary nested content: https://langchain-ai.github.io/langgraph/how-tos/streaming-content/
+## Prompt refinement task_router, user_question_routing, prompt_category 2024-07-27
+## WebSearch Hallucination issue - recursion looping - solution: routing to route_question 2024-07-28
+## Safety_check greetings, msgs, APM Sample Dataset 2024-09-29
+# VQA issue - image not recognised 2024-07-30
+# Constants IMAGES (Architecture, Overview) 2024-07-31
+# About, QnA Examples moved to mock files 2024-08-01 - deployed to build
+## 2024-08-03: VQA Streaming, Diagrams' EDGE nodes changed to END - one task at a time: 2024-08-03
+## VQA Llama-3.2-11B-Vision-Instruct 2024-10-25
+#RELEASE 2024-11-15
+## CHANGES 2024-11-22
+# MIGRATION to Gradio 5
+# Chatbot UI migrated to gr.Chatbot 
+# run_qna_agentic_system, run_vqa_agentic_system updated: ChatMessage, chat_memory, UI events
+# chat_memory VQA missing image - fixed - needs improvement
+## RELEASE 2024-11-23
+#pip freeze > requirements.txt to keep libraries synched local and HF Spaces
+#gr.Image issue: caused by __main__ root_path=str(Path.cwd())
+## RELEASE 2024-12-09
+#Confluence Integration
+#Llama-3.2-11B-Vision-Instruct max_token issue <=4096 stills
+#Safety-check refinement
+#TOGAF Vision streaming
+## Release update 2024-12-11
+#EA4ALL Podcast
+#2025-02-03 RELEASE V1
+##RETROFIT & INTEGRATION w/ EA4ALL-dev-studio-structure
+#2025-02-09 
+##UAT EA4ALL-LGS-RETRIEVER-REFACTORED
+#2025-03-10
+##AI-Assistant-UI-Message-Stream refactor
+#2025-12-04
+## Add EA4ALL-PMO-Demand-Management CrewAI Agents
+#2025-05-06
+## Add MCP Server
+#2025-05-17
+## Added PMO_MOCK_QNA examples, 
+## get_relevant_questions() - moved to utils, constants moved to configuration
+#2025-05-19
+## EA4ALL Diagram refactored, vqa_max_tokens updated
+from langchain.callbacks.tracers import LangChainTracer
+from langchain.callbacks.tracers.langchain import wait_for_all_tracers
+from langchain_community.document_loaders import ConfluenceLoader
+from langchain_core.messages import HumanMessage
+from langsmith import Client
+
+from ea4all.src.shared.configuration import BaseConfiguration, APM_MOCK_QNA, PMO_MOCK_QNA
+from ea4all.src.shared import vectorstore
+from ea4all.src.ea4all_gra.configuration import AgentConfiguration as gra
+from ea4all.src.ea4all_indexer.configuration import IndexConfiguration
+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_indexer.graph import indexer_graph
+from ea4all.src.graph import super_graph
+from ea4all.src.pmo_crew.crew_runner import run_pmo_crew
+
+import uuid
+import os
+import pandas as pd
+
+import gradio as gr
+from gradio import ChatMessage
+import time
+from PIL import Image
+
+#Set LangSmith project
+tracer = LangChainTracer(project_name=os.getenv('LANGCHAIN_PROJECT'))
+
+config = {
+    "run_name": os.getenv('LANGCHAIN_RUNNAME'), 
+    "tags": [os.getenv('EA4ALL_ENV')],
+    "callbacks":[tracer],
+    "recursion_limit": 25,
+    "configurable": {
+        "thread_id": uuid.uuid4(),
+    },
+    "stream_mode": "messages"
+}
+
+#Blocks w/ ChatInterface, BYOD, About
+with gr.Blocks(title="Your ArchitectGPT",fill_height=True, fill_width=True) as ea4all_agentUI:
+
+    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 effieciency, knowledge sharing, and get valuable insights from your IT landscape using natural language.
+        As an Enterprise Architect Agentic System I can answer questions related to Enterprise Architecture, Technology, plus the following IT Landscape sample dataset: """
+
+    agentic_vqa_desc="""
+    Hi, talk to your Architecture Diagram using natural language. Gain rapid knowledge and insights translating image to meaningful description.
+    **Disclaimer**:
+    - This feature should NOT BE USED to process inappropriate content, but ONLY FOR Architecture Diagrams
+    """
+
+    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.
+    """
+    
+        #ea4all-about
+    
+    def ea4all_about():
+        readme = e4u.load_mock_content(e4u.CFG.EA4ALL_ABOUT)
+        return readme
+   
+    #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():
+        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
+
+    #ea4all-qna-agent-conversational-with-memory
+    async def run_qna_agentic_system(prompt, chat_memory, request:gr.Request):
+        
+        format_response = ""
+
+        if not prompt:
+            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=prompt))
+            yield chat_memory
+
+        if prompt:
+            #capture user ip
+            ea4all_user = e4u.get_user_identification(request)
+
+            ##Initialise APM Graph
+            #apm_graph = e4a.apm_graph
+            #inputs = {"question": prompt, "chat_memory":chat_memory}
+            inputs = {"messages": [{"role": "user", "content": prompt}]}
+            
+            #add prompt to memory
+            chat_memory.append(ChatMessage(role="user", content=prompt))
+
+            partial_message = ""
+            async for event in super_graph.astream_events(input=inputs, config=config, version="v2"):
+            #async for event in super_graph.astream(input=inputs, config=config, subgraphs=True):
+             #   chat_memory.append(ChatMessage(role="assistant", content=str(event)))
+             #   yield chat_memory
+
+                kind = event["event"]
+                tags = event.get("tags", [])
+                name =  event['name']
+                
+                #chat_memory.append(ChatMessage(role="assistant", content=f"Running: {name}"))
+                #yield chat_memory
+
+                if name == "safety_check":
+                    #if kind == "on_chain_start":
+                    #    chat_memory.append(ChatMessage(role="assistant", content=f"- `{name}`"))
+                    #    yield chat_memory
+                    if kind == "on_chain_stream":
+                        chat_memory.append(ChatMessage(role="assistant", content=f"- `{name}`: {event['data']['chunk']['safety_status'][0]}"))  
+                        if event['data']['chunk']['safety_status'][0] == 'no': 
+                            chat_memory.append(ChatMessage(role="assistant", content=f"Safety-status: {event['data']['chunk']['safety_status'][1]}"))
+                        yield chat_memory
+                if kind == "on_chain_end" and name == "route_question":
+                    chat_memory.append(ChatMessage(role="assistant", content=f"- `{name}:` {event['data']['output']['source']}"))
+                    yield chat_memory
+                if kind == "on_chain_start" and name == "retrieve":
+                    chat_memory.append(ChatMessage(role="assistant", content=f"- `{name}` RAG\n\n"))
+                    yield chat_memory
+                if kind == "on_chain_start" and name in ("generate_web_search", "websearch", "stream_generation"):
+                    chat_memory.append(ChatMessage(role="assistant", content= f"\n\n- `{name}`\n\n"))
+                    yield chat_memory
+                if kind == "on_chain_stream" and name == "stream_generation":
+                    data = event["data"]
+                    # Accumulate the chunk of data
+                    partial_message += data['chunk']
+                    chat_memory[-1].content = partial_message
+                    time.sleep(0.05)
+                    yield chat_memory
+                if name == "grade_generation_v_documents_and_question":
+                    if kind == "on_chain_start": 
+                        chat_memory.append(ChatMessage(role="assistant", content=f"\n\n- `{name}`: "))
+                        yield chat_memory
+                    if kind == "on_chain_end":
+                        chat_memory.append(ChatMessage(role="assistant", content=f"`{event['data']['input'].source}:` {event['data']['output']}"))
+                        yield chat_memory
+                if "stream_hallucination" in tags and kind == "on_chain_start":
+                    chat_memory.append(ChatMessage(role="assistant", content=f"- `{tags[-1]}`"))
+                    yield chat_memory
+                if "stream_grade_answer" in tags and kind == "on_chain_start":
+                    chat_memory.append(ChatMessage(role="assistant", content=f"- `{tags[-1]}`"))
+                    yield chat_memory
+                if name == "supervisor":
+                    if kind == "on_chain_start":
+                        chat_memory.append(ChatMessage(role="assistant", content=f"- `{name}` "))
+                        yield chat_memory
+                    if kind == "on_chain_stream":
+                        chat_memory.append(ChatMessage(role="assistant", content=f"{event['data']['chunk']}"))
+                        yield chat_memory
+
+            os.environ["EA4ALL_" + ea4all_user.replace(".", "_")] = str(event['run_id'])
+            wait_for_all_tracers()
+
+    #Trigger Solution Architecture Diagram QnA
+    async def run_vqa_agentic_system(message, chat_memory, request:gr.Request):
+        #capture user ip
+        ea4all_user = e4u.get_user_identification(request)
+
+        """Handle file uploads and validate their types."""
+        allowed_file_types = ('JPEG', 'PNG')
+
+        print("---CALLING VISUAL QUESTION ANSWERING AGENTIC SYSTEM---")
+        print(f"Prompt: {message}")
+
+        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."))
+                        yield chat_memory
+                    else:
+                        #'vqa_image = e4u.get_raw_image(diagram) #MOVED into Graph
+                        vqa_image = diagram
+
+                        #Setup Quality Assurance Agentic System
+                        #graph = e4v.ea4all_graph(config['configurable']['vqa_model'])
+
+                        #Setup enter graph
+                        diagram_graph = e4v.diagram_graph
+
+                        partial_message = ""
+                        chat_memory.append(ChatMessage(role="assistant", content="Hi, I am working on your question..."))
+                        async for event in diagram_graph.astream_events(
+                            {"question":msg, "image": vqa_image}, config, version="v2"
+                        ):
+                            if (
+                                    event["event"] == "on_chat_model_stream"
+                                    and "vqa_stream" in event['tags']
+                                    #and event["metadata"].get("langgraph_node") == "tools"
+                                ):
+                                    partial_message += event["data"]["chunk"].content
+                                    chat_memory[-1].content = partial_message
+                                    time.sleep(e4u.CFG.STREAM_SLEEP)
+                                    yield chat_memory #, message to update prompt
+                            elif not partial_message:
+                                yield chat_memory #, message
+                        
+                        os.environ["EA4ALL_" + ea4all_user.replace(".", "_")] = str(event['run_id'])
+                        wait_for_all_tracers()
+
+            except Exception as e:
+                yield (e.args[-1])
+
+    #Run Togaf Agentic System
+    async def run_reference_architecture_agentic_system(business_query, request:gr.Request):
+
+        if len(business_query) < 50:
+            agent_response = "Please provide a valid Business Requirement content to start!"
+            yield([agent_response,gr.Tabs(visible=True), gr.Tabs(selected="id_togaf"),None, None, gr.Tabs(visible=False)])
+        else: 
+            plain_text = e4u.markdown_to_plain_text(business_query)
+            agent_response = "Generating Architecture Blueprint ---TOGAF VISION TARGET--- \n\nI am working on your request..."
+            togaf_chain = e4t.togaf_graph
+            final_diagram = ""
+            vision_message = ""
+            try:
+                async for s in togaf_chain.astream_events(
+                    {
+                        "messages": [
+                            HumanMessage(
+                                content=plain_text
+                            )
+                        ],
+                        "business_query": business_query,
+                    },
+                    config=config,
+                    version="v2"
+                ):    
+                    kind = s["event"]
+                    tags = s.get("tags", [])
+                    name = s['name']
+
+                    if "gra_stream" in tags and name == "stream_vision_target":
+                        if kind == "on_chain_stream":
+                            data = s["data"]
+                            # Accumulate the chunk of data
+                            vision_message += data['chunk'].content
+                            time.sleep(e4u.CFG.STREAM_SLEEP)
+                            yield([vision_message,gr.Tabs(visible=True), gr.Tabs(selected="id_togaf"),None, None, gr.Tabs(visible=False)])
+                    elif name == "save_diagram" and kind == 'on_chain_end': #MOVED INTO Togaf_Task3
+                        final_diagram = s['data']['output']['architecture_runway']
+                    elif ("assess_business_query" in tags or "assess_landscape" in tags) and kind == 'on_chain_start': ##'on_chat_model_stream':
+                        agent_response += f"\n\n`{tags[-1]}:{name}`"
+
+                        yield([agent_response,gr.Tabs(visible=True), gr.Tabs(selected="id_togaf"),None, None, gr.Tabs(visible=False)])
+                    
+                if vision_message=="":
+                    agent_response = "I cannot generate the Architecture Vision. Please provide a valid Business Requirement content to start!"
+                    yield([agent_response,gr.Tabs(visible=True), gr.Tabs(selected="id_togaf"),None, None, gr.Tabs(visible=False)])
+                elif "Error" not in final_diagram:
+                    yield([vision_message,gr.Tabs(visible=True), gr.Tabs(selected="id_togaf"),final_diagram, None, gr.Tabs(visible=True)])
+                else:
+                    yield([vision_message,gr.Tabs(visible=True), gr.Tabs(selected="id_togaf"),None, final_diagram, gr.Tabs(visible=True)])
+
+            except Exception as e:  
+                yield(
+                    [
+                        e.args[-1],
+                        gr.Tabs(visible=True), 
+                        gr.Tabs(selected="id_togaf"),
+                        None,
+                        None,
+                        gr.Tabs(visible=False)
+                    ]
+                )
+
+    async def run_pmo_agentic_system(prompt, chat_memory):
+        """
+        Answer a question about Project Portfolio Management and Architect Demand Management.
+
+        Args:
+            prompt (str): The propject portfolio user question
+            chat_memory (list): The tool message history
+
+        Returns:
+            str: A summary answering the user question
+        """
+        format_response = ""
+
+        if not prompt:
+            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=prompt))
+            yield chat_memory
+
+        inputs = {
+            "question": prompt,
+            "verbose": True,  # optional flags
+        }
+        
+        yield run_pmo_crew(inputs)
+
+    def ea4all_confluence():
+
+        #Confluence API Key
+        confluence_api_key = os.environ['CONFLUENCE_API_KEY']
+
+        loader = ConfluenceLoader(
+            url="https://learnitall.atlassian.net/wiki", username="learn-it-all@outlook.com", 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']
+
+    #EA4ALL-Agentic system menu
+    with gr.Tabs(selected="how_to") as tabs:
+        with gr.Tab(label="Architect Demand Management"):
+            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 Architect Companion", type="messages")
+                    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 prompt examples", open=False):
+                        pmo_examples = gr.Dropdown(e4u.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 Architect Companion", type="messages")
+                    qna_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 prompt examples", open=False):
+                        qna_examples = gr.Dropdown(e4u.get_relevant_questions(APM_MOCK_QNA), value=None,label="Questions", interactive=True)
+                    gr.ClearButton([ea4all_chatbot,qna_prompt], value="Clear", size="sm", visible=False)
+                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")
+            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 prompt examples", open=False):
+                vqa_examples = gr.Dropdown(e4u.get_vaq_examples(), value=None,label="Diagram and Questions", interactive=True)
+            gr.ClearButton([ea4all_vqa,vqa_prompt,vqa_examples], value="Clear", size="sm", visible=True)
+        with gr.Tab(label="Reference Architecture", id="id_refarch"):
+            with gr.Tabs(selected="id_dbr") as tabs_reference_architecture:
+                with gr.Tab(label='Business Requirement', id="id_dbr"):
+                    gr.Markdown(value=agentic_togaf_desc)
+                    dbr_text=gr.TextArea(value=init_dbr, lines=14, interactive=True)
+                    with gr.Row():
+                        dbr_file=gr.File(
+                            value=e4u._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'
+                        )
+                        dbr_run=gr.Button(scale=None,value="Run Reference Architecture")
+                        dbr_cls=gr.ClearButton([dbr_file,dbr_text])
+                with gr.Tab(label='Confluence Integration', id="id_confluence"):
+                    confluence_list = gr.Dropdown(value=None, label="Confluence Pages", interactive=True)
+                    confluence_df = gr.DataFrame(visible=False, headers=["title", "source", "page_content"])  
+                    @gr.render(inputs=[confluence_list,confluence_df])
+                    def show_page(page, df):
+                        if page:
+                            with gr.Row():
+                                with gr.Column():
+                                    dbr_confluence =gr.Button(scale=None,value="Run Reference Architecture")
+                                with gr.Column():
+                                    btn=gr.Button("Clear")
+                            with gr.Row(variant='default', show_progress=True):
+                                page_content = gr.Markdown(filter_page(df,page), line_breaks=True)
+                                btn.click(lambda: gr.Dropdown(value=None), None, confluence_list)
+                                dbr_confluence.click(run_reference_architecture_agentic_system,show_progress='full', inputs=[page_content],outputs=[togaf_vision,tabs_togaf,tabs_reference_architecture, architecture_runway, diagram_header, tab_diagram])
+                with gr.Tab(label='Reference Architecture',visible=False, id="id_togaf") as tabs_togaf:
+                    togaf_vision=gr.Markdown(value='### Reference Architecture: Vision and Target')
+                with gr.Tab(label="Target Architecture Runway",visible=False, id="id_runway") as tab_diagram:
+                    diagram_header=gr.Markdown(visible=True)
+                    architecture_runway=gr.Image(label="Target Architecture Runway",interactive=False,visible=True, scale=10)
+        with gr.Tab(label="Overview", id="how_to"):
+            gr.Markdown(
+                """
+                    # Title
+        
+                    **Explore, Share, Together:** harness the value of `Enterprise Architecture in the era of Generative AI` to positively impact individuals and organisations.\n
+
+                    ## Overview
+                """
+            ),
+            gr.Image(
+                get_image(e4u.CFG.EA4ALL_ARCHITECTURE),
+                show_download_button=False,
+                container=False,
+                show_share_button=False,
+                )
+            gr.Markdown(
+                """
+                    ## Journey
+
+                    Audio overview summarising the key learnings, challenges, so what, stats from day-1 to last sprint. (**Powered by Google NoteBookLM**)
+
+                """
+            )
+            podcast = gr.Audio(
+                type="filepath",
+                value=os.path.join(BaseConfiguration.ea4all_store,e4u.CFG.EA4ALL_PODCAST), 
+                label="EA4ALL Journey Podcast", 
+                show_download_button=False,
+                autoplay=False,
+                container=True,
+                interactive=False,
+            )
+            gr.Markdown(ea4all_about)
+
+    #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):
+
+        #capture user IP address
+        #ea4all_user = e4u.get_user_identification(request)
+        gr.Info("Thank you for connecting! I'd love to hear your feedback! Thumbs up or Thumbs down. LinkedIn comment.")
+
+        # 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")
+
+        return (
+            apm_columns, 
+            [prompt], 
+            [prompt],
+            [prompt],
+            gr.Dropdown(choices=page_list['title'].values.tolist()), 
+            gr.DataFrame(value=page_list), 
+            gr.DataFrame(value=df),
+            gr.DataFrame(value=pmo_df),
+        )
+
+    #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)
+    
+    #Upload & clear business requirement
+    def load_dbr(file):
+        return file.decode()
+    
+    def unload_dbr():
+        return gr.TextArea(visible=False)
+
+    def on_dbrtext(file):
+        if file:
+            return gr.TextArea(visible=True)
+        return gr.TextArea(visible=False)
+    
+    #Upload & clear business requirement
+    def load_dbr(file):
+        return file.decode()
+    
+    def unload_dbr():
+        return gr.TextArea(visible=False)
+
+    #Podcast upload progress
+    podcast.change(show_progress='full')
+   
+    #Togaf upload file
+    dbr_file.clear(unload_dbr,outputs=dbr_text)
+    dbr_file.change(on_dbrtext,inputs=dbr_file,outputs=dbr_text)
+    dbr_file.upload(load_dbr,inputs=dbr_file, outputs=dbr_text)
+    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],ea4all_chatbot)
+    qna_prompt.submit(lambda: "", None, [qna_prompt])
+    ea4all_chatbot.like(fn=get_user_feedback)
+    qna_examples.input(lambda value: value, qna_examples, qna_prompt)
+
+    #Execute Reference Architecture
+    dbr_run.click(run_reference_architecture_agentic_system,show_progress='full',inputs=[dbr_text],outputs=[togaf_vision,tabs_togaf,tabs_reference_architecture, architecture_runway, diagram_header, tab_diagram])
+
+    #vqa_chatbot (ChatInterface -> Chatbot)
+    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
+        )
+
+    chat_msg = vqa_prompt.submit(add_message, [vqa_prompt, ea4all_vqa], [vqa_prompt, ea4all_vqa])
+    bot_msg = chat_msg.then(run_vqa_agentic_system, [vqa_prompt, ea4all_vqa], ea4all_vqa, api_name="bot_response")
+    
+    ea4all_vqa.like(fn=get_user_feedback)
+    vqa_examples.input(lambda value: value, vqa_examples, vqa_prompt)
+
+    #Invoke CrewAI PMO Agentic System
+    pmo_prompt.submit(run_pmo_agentic_system,[pmo_prompt,pmo_chatbot],pmo_chatbot)
+    pmo_prompt.submit(lambda: "", None, [pmo_prompt])
+    pmo_examples.input(lambda value: value, pmo_examples, pmo_prompt)
+
+    #Set initial state of apm and llm
+    ea4all_agentUI.load(ea4all_agent_init, outputs=[ea4all_agent_metadata,ea4all_chatbot, ea4all_vqa, pmo_chatbot, confluence_list, confluence_df, apm_df, pmo_df])

ea4all/ea4all_mcp.py

@@ -0,0 +1,28 @@
+import gradio as gr
+
+def letter_counter(word, letter):
+    """
+    Count the number of occurrences of a letter in a word or text.
+
+    Args:
+        word (str): The input text to search through
+        letter (str): The letter to search for
+
+    Returns:
+        str: A message indicating how many times the letter appears
+    """
+    word = word.lower()
+    letter = letter.lower()
+    count = word.count(letter)
+    return count
+
+demo = gr.Interface(
+    fn=letter_counter,
+    inputs=["textbox", "textbox"],
+    outputs="number",
+    title="Letter Counter",
+    description="Enter text and a letter to count how many times the letter appears in the text."
+)
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

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_overview.txt

@@ -0,0 +1,96 @@
+## 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.
+
+
+## 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, meta-faiss, gradio and Openai.<italic>
+
+    - Python
+        - Pandas
+        - Langchain
+        - Langsmith
+        - Langgraph
+        - Huggingface
+
+    - RAG (Retrieval Augmented Generation)
+        - Vectorstore
+
+    - Prompt Engineering
+        - Strategy & tactics: Task / Sub-tasks
+        - Agentic Workflow
+
+    - Models: 
+        - OpenAI
+        - Llama
+    
+    - 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
+    
+    - User Interface
+        - Gradio
+
+    - Hosting: Huggingface Space
+
+## Agentic System Architecture

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/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,931 @@
+"""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.
+"""
+import json
+import tempfile
+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.history 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
+
+##Utils and tools
+from langchain_community.document_loaders import JSONLoader
+from langchain_community.utilities import BingSearchAPIWrapper
+from langchain_community.tools.bing_search.tool import BingSearchResults
+
+from operator import itemgetter
+
+#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 APMState, InputState
+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
+
+# This file contains sample APM QUESTIONS
+APM_MOCK_QNA = "apm_qna_mock.txt"
+
+async def retrieve_documents(
+    state: APMState, *, 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 {"documents": 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
+        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: 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
+def get_relevant_answers(query, config: RunnableConfig):
+
+    if query != "":
+        #retriever.vectorstore.index.ntotal
+        #retriever = retriever_faiss(user_ip)
+        #response = retriever.invoke({"standalone_question": query})
+        
+        response = retrieve_documents(query, 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: APMState, _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.documents
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    # Score each doc
+    filtered_docs = []
+    web_search = "No"
+    for d in documents:
+        score = retrieval_grader(llm).ainvoke(
+            {"user_question": question, "document": d.page_content}
+        )
+        grade = score["score"]
+        # 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"
+    
+    return {"documents": filtered_docs, "question": question, "web_search": web_search}
+
+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
+    web_search = state.web_search
+    getattr(state,'documents')
+
+    if web_search == "Yes":
+        # 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:APMState, config: RunnableConfig):
+    """
+    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,'documents')
+    generation = getattr(state,'generation')
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
+
+    if getattr(state,'web_search') == "Yes":
+        #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---")
+            yield "useful"
+        else:
+            print("---DECISION: GENERATION DOES NOT ADDRESS QUESTION---")
+            yield "not useful"
+    else:
+        print("---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---")
+        yield "not supported"
+
+async def apm_query_router(
+    state: APMState, 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})
+
+    datasource = extract_structured_output(response.content)['datasource']
+
+    return datasource
+
+async def retrieve(
+    state: APMState, 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 {"documents": format_docs(documents['cdocs']), "question": question, "rag":getattr(state,'rag')}
+
+async def websearch(
+        state: APMState, config: RunnableConfig
+    ) -> dict[str,any]:
+    """
+    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
+    """
+
+    # print("---WEB SEARCH---")
+    ##Rephrase user question to lead bettern LLM response
+    question = user_query_rephrasing(state=state, config=config)['question']
+
+    ##API Wrapper
+    search = BingSearchAPIWrapper()
+
+    ##Bing Search Results
+    web_results = BingSearchResults(k=3, api_wrapper=search)
+    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 {"documents": format_docs(docs), "question": question, "web_search": "Yes", "generation": None}
+
+### Edges ###
+def route_to_node(state:APMState):
+    
+    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: APMState, config: RunnableConfig
+) -> dict[str, any]:
+    """
+    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: APMState, config: RunnableConfig
+):
+    configuration = AgentConfiguration.from_runnable_config(config)
+
+    llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url,streaming=configuration.streaming)
+
+    async for s in state:
+        documents = getattr(s,"documents")
+        web_search = getattr(s,"web_search")
+        question = getattr(s,"question")
+        chat_memory = getattr(s,"chat_memory")
+
+    # Prompt Web Search generation
+    if web_search == "Yes":
+        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: APMState, config: RunnableConfig
+    ) -> dict[str, any]:
+    """
+    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,'documents')
+    web_search = getattr(state,'web_search') 
+    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 web_search == "Yes" else ["apm_stream"]
+    gen = RunnableGenerator(stream_generation).with_config(tags=tags)
+    generation=""
+    async for message in gen.astream(state):
+        generation = ''.join([generation,message])
+   
+    return {"documents": documents, "question": question, "generation": generation, "web_search": web_search}
+
+#ea4all-qna-agent-conversational-with-memory
+async def apm_agentic_qna(
+    state:APMState, 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, "web_search": "No", "generation": None}
+
+async def final(state: APMState):
+    return {"safety_status": state}
+
+async def choose_next(state: APMState):
+    return "exit" if state.safety_status[0] == 'no' else "route"
+
+class SafetyCheck:
+    def apm_safety_check(self,state: APMState, 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: APMState, 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(APMState, input=InputState, 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,87 @@
+"""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
+
+# 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
+    safety_status: Optional[Tuple[str, str, str]] = None
+
+    """Messages track the primary execution state of the agent.
+
+    Typically accumulates a pattern of Human/AI/Human/AI messages; if
+    you were to combine this template with a tool-calling ReAct agent pattern,
+    it may look like this:
+
+    1. HumanMessage - user input
+    2. AIMessage with .tool_calls - agent picking tool(s) to use to collect
+         information
+    3. ToolMessage(s) - the responses (or errors) from the executed tools
+    
+        (... repeat steps 2 and 3 as needed ...)
+    4. AIMessage without .tool_calls - agent responding in unstructured
+        format to the user.
+
+    5. HumanMessage - user responds with the next conversational turn.
+
+        (... repeat steps 2-5 as needed ... )
+    
+    Merges two lists of messages, updating existing messages by ID.
+
+    By default, this ensures the state is "append-only", unless the
+    new message has the same ID as an existing message.
+
+    Returns:
+        A new list of messages with the messages from `right` merged into `left`.
+        If a message in `right` has the same ID as a message in `left`, the
+        message from `right` will replace the message from `left`."""
+
+
+class Router(TypedDict):
+    """Classify a user query."""
+    logic: str
+    datasource: Optional[Literal["vectorstore", "websearch"]] = None
+
+@dataclass(kw_only=True)
+class APMState(InputState):
+    """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
+        web_search: whether to add search
+        retrieved: list of documents retrieved by the retriever
+        rag: last RAG approach used
+        chat_memory: user chat memory
+        generation: should the agent generate a response
+        documents: list of documents retrieved by the retriever
+    """
+    router: Optional[Router] = None
+    source: Optional[str] = None
+    rag: Optional[str] = None
+    web_search: Optional[str] = None
+    chat_memory: Optional[str] = None
+    generation: Optional[str] = None
+    retrieved: Optional[List[str]] = None
+    documents: 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,409 @@
+"""
+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.
+"""
+
+#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.runnables import RunnableConfig
+from langchain_core.runnables.history import RunnableLambda
+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 TogafState
+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: TogafState, config: RunnableConfig) -> dict:
+    # 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['messages'][-1].content,
+                "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={
+            #"messages": [
+            #    HumanMessage(
+            #        content=user_response, name="togaf_ask_human"
+            #    )
+            #],
+            "business_query": business_query,
+        }
+    )
+
+#DEFINE Helper functions
+def create_team_supervisor(
+        state:Union[TogafState, Dict], 
+        config:RunnableConfig) -> RunnableLambda:
+    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, return_only_args=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:TogafState, members: List[str]):
+    results = {
+        "messages": [SystemMessage(content=str(state))],
+        "team_members": ", ".join(members),
+        "business_query": state.get('business_query'),
+        "next": state.get('next'),
+    }
+    return results
+
+def task2_enter_chain(state:TogafState, members: List[str]):
+    results = {
+        "messages": [SystemMessage(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:TogafState, members: List[str]):
+    results = {
+      "messages": [SystemMessage(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: TogafState) -> TogafState:
+    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: TogafState) -> TogafState:
+    results = {}
+    results['messages'] = [state.get("messages")[-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:TogafState, config:RunnableConfig) -> Command[Literal["togaf_supervisor", "return"]]:
+    print(f"--- TOGAF AGENTIC team ---  safety/quality review of the user requirement: {state['messages'][-1].content}") 
+    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="togaf_supervisor",
+            )
+    else:
+        return Command(
+            # state update
+            update={"query_status": False},
+            # control flow
+            goto="return",
+            )   
+
+def return_2user(state:TogafState):
+    message = '{"binary_score":"no"}'
+
+    return {
+        "messages": [AIMessage(content=str(message), name="return")],
+        "next": "end",
+    }
+
+async def enter_graph(state:TogafState, config: RunnableConfig) -> dict:
+
+    print(f"--- Entered TOGAF AGENTIC team to --- {state['messages'][-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 = getattr(state,'user_feedback', state['messages'][-1].content)
+    
+    #busines_query = load_mock_content(state.get('user_feedback')),
+
+    return {**state, "business_query": state['messages'][-1].content}
+
+## TOGAF Orchestrator Graph
+task1_business_query_chain = (
+    functools.partial(task1_enter_chain, members=task1_graph.nodes) | 
+    task1_graph
+)
+
+task2_assess_asis_chain = (
+    functools.partial(task2_enter_chain, members=task2_graph.nodes)
+    | task2_graph
+)
+
+task3_vision_target_chain = (
+    functools.partial(task3_enter_chain, members=task3_graph.nodes)
+    | task3_graph
+)
+
+# Define the graph.
+workflow = StateGraph(TogafState, 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("togaf_supervisor", create_team_supervisor)
+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", "togaf_supervisor")
+workflow.add_edge("assess_asis", "togaf_supervisor")
+workflow.add_edge("generate_tobe", "togaf_supervisor")
+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,151 @@
+from pydantic import Field
+from typing_extensions import (
+    Annotated
+)
+import operator
+from typing import (
+    Optional,
+    Annotated, 
+    Sequence,
+    List
+)
+from dataclasses import dataclass, field
+from typing import Optional
+
+from langchain_core.messages import (
+    BaseMessage,
+)
+
+from langgraph.graph import MessagesState
+
+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:
+    """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: str
+
+# Task-2 Graph State
+dataclass(kw_only=True)
+class Task2State(InputState):
+    """
+    Represents the 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]] = None
+    team_members: Optional[List[str]] = None
+    business_query: Optional[str] = None
+    landscape_asis: Optional[List[str]] = None
+    identified_asis: Optional[LandscapeAsIs] = None
+    biz_capability: Optional[BusinessCapability] = None
+    landscape_gap: Optional[CapabilityGap] = None
+    next: Optional[str] = None
+
+# 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]] = None
+    team_members: Optional[List[str]] = None
+    stakeholder: Optional[StakeholderList] = None
+    principles: Optional[Principles] = None
+    requirement: Optional[ListRequirement] = None
+    intent: Optional[ListObjective] = None
+    userjourney: Optional[UserJourney] = None
+    biz_capability: Optional[BusinessCapability] = None
+    landscape_asis: Optional[List[str]] = None
+    identified_asis: Optional[LandscapeAsIs] = None
+    landscape_gap: Optional[CapabilityGap] = None
+    vision_target: Optional[str] = None
+    architecture_runway: Optional[str] = None
+    next: Optional[str] = None
+
+# Top-level graph state
+dataclass(kw_only=True)
+class TogafState(MessagesState):
+    """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.
+    """
+
+    business_query: Optional[str] = None
+    query_status: Optional[bool] = field(default=False)
+    stakeholder: Optional[StakeholderList] = None
+    principles: Optional[Principles] = None
+    requirement: Optional[ListRequirement] = None
+    intent: Optional[ListObjective] = None
+    userjourney: Optional[UserJourney] = None
+    biz_capability: Optional[BusinessCapability] = None
+    landscape_asis: Optional[List[str]] = None
+    identified_asis: Optional[LandscapeAsIs] = None
+    landscape_gap: Optional[CapabilityGap] = None
+    vision_target: Optional[str] = None
+    architecture_runway: Optional[str] = None
+    next: Optional[str] = None

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 = getattr(state, "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 = getattr(state, "next")
+
+    return {
+        "messages": [AIMessage(content=str(final_response), name=name)],
+        "requirement": business_reqs,
+        "intent": str(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]] = None
+    team_members: Optional[List[str]] = None
+    requirement: Optional[ListRequirement] = None
+    intent: Optional[ListObjective] = None
+    userjourney: Optional[UserJourney] = None
+    stakeholder: Optional[StakeholderList] = Field(description="List of stakeholder", default="Not identified")
+    biz_capability: Optional[BusinessCapability] = None
+    next: Optional[str] = None

ea4all/src/ea4all_gra/togaf_task2/graph.py

@@ -0,0 +1,441 @@
+import ast
+
+#core libraries
+from langchain_core.runnables import RunnableConfig
+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
+
+# 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---")
+    if getattr(state, 'landscape_asis'):
+        business_query = state['business_query']
+    else:
+        #Generate first business query - capture business input
+        try:
+            content = ast.literal_eval(state.messages[-1].content)
+            intent = content['intent'].lower()[1:-1].replace("'","")
+        except Exception as e:
+            # Falls here if the content is not a dict: Transform Query flow
+            intent = state.messages[-1].content
+        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 = getattr(state,'business_query')
+    landscape_asis = getattr(state,'landscape_asis')
+
+    # Score each doc
+    filtered_docs = []
+    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]
+
+    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)
+        grade = extracted_answer['binary_score'] ##REVIEW PROMPT W/ LLAMA3.1-70B
+        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
+    content = ';'.join(str(app) for app in state.identified_asis)
+        
+    values = {
+        "application": content,
+        "capability": state.biz_capability[1:-1].replace("'",""),
+        }
+
+    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,49 @@
+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,
+)
+
+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]] = None
+    team_members: Optional[List[str]] = None
+    business_query: Optional[str] = None
+    landscape_asis: Optional[List[str]] = None
+    identified_asis: Optional[LandscapeAsIs] = None
+    biz_capability: Optional[BusinessCapability] = None
+    landscape_gap: Optional[CapabilityGap] = None
+    next: Optional[str] = None

ea4all/src/ea4all_gra/togaf_task3/graph.py

@@ -0,0 +1,280 @@
+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 = load_mock_content('strategic_principles.txt') ##REFACTORING NEEDED
+    values = {"strategic_principles": md(strategic_principles)}
+    
+    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),values))
+    
+    ##RE-use business reqs extractor
+    identified_principles = extract_detailed_business_requirements(model, Principles, "architecture principles", md(strategic_principles))
+    
+    name = getattr(state, 'next')
+    return {
+        "messages": [AIMessage(content=str(identified_principles), name=name)],
+        "principles": identified_principles,
+        "business_query": getattr(state, 'business_query'),
+        "business_goal": getattr(state, 'intent'),
+        "business_stakeholder": getattr(state, 'stakeholder'),
+        "biz_capability": getattr(state, 'biz_capability'),
+        "requirement": getattr(state, 'requirement'),
+        "user_journey": getattr(state, 'userjourney'),
+        "landscape_asis": getattr(state, 'landscape_asis'),
+        "identified_asis": getattr(state, 'identified_asis'),
+        "landscape_gap": getattr(state, 'landscape_gap')
+    }
+
+async def stream_vision_target(state: Task3State, config: RunnableConfig):
+    ##MAX_TOKENS OPTIMISATION 2024-07-08
+
+    async for s in state:
+        intent = getattr(s, 'intent')
+        stakeholder = getattr(s, 'stakeholder')
+        biz_capability = getattr(s, 'biz_capability')
+        requirement = getattr(s, 'requirement')
+        userjourney = getattr(s, 'userjourney')
+        identified_principles = getattr(s, 'principles')
+        landscape_asis = getattr(s, 'landscape_asis')
+        identified_asis = getattr(s, 'identified_asis')
+        landscape_gap = getattr(s, 'landscape_gap')
+
+    # Prompt
+    vision_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_vision_target')
+   
+    values =  {
+            "business_goal": intent,
+            "business_stakeholder": stakeholder,
+            "business_capability": biz_capability,
+            "principles": identified_principles,
+            "requirement": requirement,
+            "user_journey": userjourney,
+            "landscape_asis": landscape_asis,
+            "identified_asis": identified_asis,
+            "landscape_gap": 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 = getattr(state, 'next')
+
+    return {
+        "messages": [AIMessage(content=generation, name=name)],
+        "principles": getattr(state, 'principles'),
+        "business_query": getattr(state, 'business_query'),
+        "intent": getattr(state, 'intent'),
+        "stakeholder": getattr(state, 'stakeholder'),
+        "biz_capability": getattr(state, 'biz_capability'),
+        "requirement": getattr(state, 'requirement'),
+        "userjourney": getattr(state, 'userjourney'),
+        "landscape_asis": getattr(state, 'landscape_asis'),
+        "identified_asis": getattr(state, 'identified_asis'),
+        "landscape_gap": getattr(state, 'landscape_gap'),
+        "vision_target": generation
+    }
+
+def generate_architecture_runway(state: Task3State, config: RunnableConfig):
+    stakeholder = getattr(state, 'stakeholder')
+    biz_capability = getattr(state, 'biz_capability')
+    userjourney = getattr(state, 'userjourney')
+    identified_asis = getattr(state, 'identified_asis')
+    intent = getattr(state, '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 = getattr(state, '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)
+
+    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 {input_img}"
+
+    return{"architecture_runway": response}
+
+def generate_reference_architecture(state: Task3State):
+    ##BY PASS to generate principles
+    return {
+        "business_query": getattr(state, 'business_query'),
+        "intent": getattr(state, 'intent'),
+        "stakeholder": getattr(state, 'stakeholder'),
+        "biz_capability": getattr(state, 'biz_capability'),
+        "requirement": getattr(state, 'requirement'),
+        "userjourney": getattr(state, 'userjourney'),
+        "landscape_asis": getattr(state, 'landscape_asis'),
+        "identified_asis": getattr(state, 'identified_asis'),
+        "landscape_gap": getattr(state, 'landscape_gap'),
+      }
+
+async def stream_vision_target(state: Task3State, config: RunnableConfig):
+    ##MAX_TOKENS OPTIMISATION 2024-07-08
+
+    async for s in state:
+        intent = getattr(s, 'intent')
+        stakeholder = getattr(s, 'stakeholder')
+        biz_capability = getattr(s, 'biz_capability')
+        requirement = getattr(s, 'requirement')
+        userjourney = getattr(s, 'userjourney')
+        identified_principles = getattr(s, 'principles')
+        landscape_asis = getattr(s, 'landscape_asis')
+        identified_asis = getattr(s, 'identified_asis')
+        landscape_gap = getattr(s, 'landscape_gap')
+
+    # Prompt
+    vision_prompt = hub.pull('learn-it-all-do-it-all/ea4all_togaf_vision_target')
+   
+    values =  {
+            "business_goal": intent,
+            "business_stakeholder": stakeholder,
+            "business_capability": biz_capability,
+            "principles": identified_principles,
+            "requirement": requirement,
+            "user_journey": userjourney,
+            "landscape_asis": landscape_asis,
+            "identified_asis": identified_asis,
+            "landscape_gap": landscape_gap
+        }
+
+    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,vision_prompt,values))
+    vision_chain = vision_prompt | model
+ 
+    for output in vision_chain.stream(values):
+        yield(output)
+
+##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,66 @@
+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]] = None
+    team_members: Optional[List[str]] = None
+    business_query: Optional[str] = None
+    landscape_asis: Optional[List[str]] = None
+    identified_asis: Optional[LandscapeAsIs] = None
+    biz_capability: Optional[BusinessCapability] = None
+    landscape_gap: Optional[CapabilityGap] = None
+    stakeholder: Optional[StakeholderList] = None
+    principles: Optional[Principles] = None
+    requirement: Optional[ListRequirement] = None
+    intent: Optional[ListObjective] = None
+    userjourney: Optional[UserJourney] = None
+    vision_target: Optional[str] = None
+    architecture_runway: Optional[str] = None
+    next: Optional[str] = None

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,405 @@
+"""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
+from langgraph.checkpoint.memory import MemorySaver
+
+#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.state import State
+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="Should be a string describing the image title.")
+
+@tool("vqa_diagram")
+@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 respons 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})
+
+    return response
+
+##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 = """You are an expert on identifying images as architecture diagrams, flowchart and whether they are innapropriate content to be processed.
+Given the conversation above, is the image safe to be processed? Does the image represent an architecture diagram or flowchart?"
+"""
+
+    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)
+    
+    # Parse out the function call
+    architecture_image = result['isArchitectureImage']
+    safe_request = result['isSafe']
+    description = result['description']
+
+    if architecture_image and safe_request:
+        print("---ROUTE REQUEST TO DIAGRAM SUPERVISOR---")
+        print(f"Architecture Diagram: {architecture_image} --- isSafe: {safe_request} --- {question} --- {description}")
+        result = True
+    else:
+        print("---ROUTE REQUEST TO FINISH---")
+        print(f"Architecture Diagram: {architecture_image} --- isSafe: {safe_request} -- What is it? {description}")
+        result = False
+    
+    return {'safety_status': result}
+
+def call_finish(state):
+    return {
+        "state": state,
+        "messages": [],
+        "next": "end",
+    } 
+
+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):
+    return "diagram_supervisor" if state.safety_status 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.
+    """
+
+    answer: str
+    """Answer to user's question about the Architectural Diagram."""
+
+@dataclass(kw_only=True)
+class OverallState(InputState):
+    """Represents the overall state of the Diagram graph."""
+
+    """Attributes:
+    messages: list of messages
+    safety_status: safety status of the diagram provided by the user
+    error: tool error
+    next: next tool to be called
+    """
+    
+    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]] = None
+    safety_status: Optional[bool] = None
+    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--- Routing to {_goto} \n User Question: {state['messages'][-1].content}")
+
+        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=response.get('generation', response['safety_status']), 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 APMState
+
+    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 = APMState(**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,161 @@
+"""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"
+
+@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,478 @@
+"""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
+class CFG:
+    # Constants
+    EA4ALL_ARCHITECTURE = "ea4all_architecture.png"
+    EA4ALL_OVERVIEW = "ea4all_overview.png"
+    EA4ALL_ABOUT = "ea4all_overview.txt"
+    EA4ALL_PODCAST = "ea4all_podcast.wav"
+    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_vaq_examples():
+    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):
+    try:
+        with open(_join_paths(ea4all_config.ea4all_store,file_path), "r") as file:
+            content = file.read()
+            return content
+    except ValueError as e:
+        return 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)

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,105 @@
+from typing import Literal, Annotated
+from typing_extensions import TypedDict
+import json
+import tempfile
+
+from langchain_core.runnables import 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]) -> str:
+    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 supervisor_node
+
+async def websearch(state: State):
+    """
+    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
+    search = BingSearchAPIWrapper()
+
+    question = state.get('messages')[-1].content
+
+    ##Bing Search Results
+    web_results = BingSearchResults(
+        k=5, 
+        api_wrapper=search,
+        handle_tool_error=True,
+    )
+    
+    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)}}