ea4all-mcp-lgs-sync-UAT-passed

ea4all/ea4all_mcp.py

@@ -8,8 +8,6 @@
 ## APPLY latest version of LGS Agentic AI - tbs
 
 from langchain.callbacks.tracers import LangChainTracer
-from langchain.callbacks.tracers.langchain import wait_for_all_tracers
-from langchain_core.messages import HumanMessage
 from langchain_core.runnables import RunnableConfig
 
 from ea4all.src.shared.configuration import BaseConfiguration, APM_MOCK_QNA, PMO_MOCK_QNA
@@ -23,7 +21,6 @@ from ea4all.src.shared.utils import (
     get_vqa_examples, 
     _join_paths,
     EA4ALL_ARCHITECTURE,
-    EA4ALL_PODCAST,
 )
 
 #from ea4all.src.pmo_crew.crew_runner import run_pmo_crew
@@ -78,6 +75,8 @@ async def run_qna_agentic_system(question: str) -> AsyncGenerator[list, None]:
     Returns:
         reponse: Response to user's architectural question.
     """
+    from ea4all.src.ea4all_vqa.state import InputState
+    from langchain_core.messages import HumanMessage
 
     format_response = ""
     chat_memory = []
@@ -86,7 +85,11 @@ async def run_qna_agentic_system(question: str) -> AsyncGenerator[list, None]:
         chat_memory.append(ChatMessage(role="assistant", content=format_response))
     else:
         index = await call_indexer_apm(config) #call indexer to update the index
-        response = await apm_graph.ainvoke({"question": question}, config=config)
+
+        input_data = InputState(
+            messages=[HumanMessage(content=question)]
+        )
+        response = await apm_graph.ainvoke(input=input_data, config=config)
         chat_memory.append(ChatMessage(role="assistant", content=response['generation']))
 
     yield chat_memory
@@ -102,6 +105,8 @@ async def run_vqa_agentic_system(question: str, diagram: str, request: gr.Reques
     Returns:
         response: Response to user's question.
     """
+    from ea4all.src.ea4all_vqa.state import InputState
+    from langchain_core.messages import HumanMessage
 
     #capture user ip
     #ea4all_user = e4u.get_user_identification(request)
@@ -122,7 +127,7 @@ async def run_vqa_agentic_system(question: str, diagram: str, request: gr.Reques
         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]        
+        diagram = str(message['files'][-1]) ##chat_memory[-1]['content'][-1]        
         msg = message['text'] ##chat_memory[-2]['content']
         print(f"---DIAGRAM: {diagram}---")
         try:
@@ -133,11 +138,15 @@ async def run_vqa_agentic_system(question: str, diagram: str, request: gr.Reques
                 if diagram_.format not in allowed_file_types:
                     #chat_memory.append(ChatMessage(role="assistant", content="Invalid file type. Allowed file types are JPEG and PNG."))
                     print(f"---DIAGRAM: {diagram.format} is not a valid file type. Allowed file types are JPEG and PNG.---")
-                #else:
-                #'vqa_image = e4u.get_raw_image(diagram) #MOVED into Graph
 
                 vqa_image = diagram
-                response = await diagram_graph.ainvoke({"question":msg, "image": vqa_image}, config)
+                # Ensure input matches expected type for ainvoke
+                input_data = InputState(
+                    messages=[HumanMessage(content=msg)],
+                    image=vqa_image
+                )
+                response = await diagram_graph.ainvoke(input=input_data, config=config)
+                
                 chat_memory.append(ChatMessage(role="assistant", content=response['messages'][-1].content if len(response['messages']) else response['safety_status']['description']))
                 
                 yield chat_memory
@@ -157,10 +166,10 @@ async def run_reference_architecture_agentic_system(business_query: str) -> Asyn
     """
 
     if len(business_query) < 20:
-        agent_response = "Please provide a valid Business Requirement content to start!"
+        agent_response = "Please provide a valid Business Requirement to start!"
         yield([agent_response, None])
     else: 
-        inputs = {"business_query": [{"role": "user", "content": business_query}]} #user response
+        inputs = {"messages": [{"role": "user", "content": business_query}]} #user response
         index = await call_indexer_apm(config) #call indexer to update the index
         response = await togaf_graph.ainvoke(
             input=inputs, 

ea4all/src/ea4all_apm/graph.py

@@ -13,6 +13,7 @@ about an IT Landscape or Websearch.
 import os
 
 from langgraph.graph import END, StateGraph
+from langgraph.types import Command
 
 #core libraries
 from langchain_core.runnables import RunnableConfig
@@ -30,7 +31,7 @@ from langchain.load import dumps, loads
 from langchain.hub import pull
 
 from operator import itemgetter
-from typing import AsyncGenerator, AsyncIterator
+from typing import AsyncGenerator
 
 #compute amount of tokens used
 import tiktoken
@@ -46,6 +47,7 @@ from ea4all.src.shared.utils import (
     extract_structured_output, 
     extract_topic_from_business_input,
     _join_paths,
+    format_docs,
 )
 from ea4all.src.shared import vectorstore
 from ea4all.src.tools.tools import (
@@ -70,7 +72,7 @@ async def retrieve_documents(
         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)
+        response = await retriever.ainvoke(state.get('question'), config)
         return {"messages": response}
 
 async def apm_retriever(config: RunnableConfig):
@@ -82,7 +84,11 @@ async def apm_retriever(config: RunnableConfig):
 # Few Shot Examples
 few_shot_step_back_examples = [
     {
-        "input": "Who can I talk to about innovation?",
+        "input": "Who can I talk about innovation?",
+        "output": '{"datasource": "vectorstore, "topic":"who can I talk to"}"}',
+    },
+    {
+        "input": "Who's the architect responsible for AI landscape?",
         "output": '{"datasource": "vectorstore, "topic":"who can I talk to"}"}',
     },
     {
@@ -351,7 +357,7 @@ def user_query_rephrasing(
         state: OverallState, _prompt=None, *, config: RunnableConfig
     ) -> dict[str,str]:
 
-    question = getattr(state,'question')
+    question = state.get('question')
 
     configuration = AgentConfiguration.from_runnable_config(config)
     # 'model = load_chat_model(configuration.query_model)
@@ -373,14 +379,10 @@ def user_query_rephrasing(
     try:
         question = result['rephrased']
     except Exception:
-        question = state.question
+        question = state.get('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
 ):  
@@ -466,9 +468,9 @@ async def grade_documents(state, config: RunnableConfig):
     configuration = AgentConfiguration.from_runnable_config(config)
 
     print("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
-    question = state.question
-    documents = state.messages
-    source = state.source
+    question = state.get('question')
+    documents = state.get('messages')
+    source = state.get('source')
     llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
 
     # Score each doc
@@ -504,9 +506,9 @@ def decide_to_generate(state):
     """
 
     print("---ASSESS GRADED DOCUMENTS---")
-    state.question
-    source = state.source
-    getattr(state,'documents')
+    state.get('question')
+    source = state.get('source')
+    state.get('documents')
 
     if source == "websearch":
         # All documents have been filtered check_relevance
@@ -534,12 +536,12 @@ def grade_generation_v_documents_and_question(
 
     configuration = AgentConfiguration.from_runnable_config(config)
 
-    question = getattr(state,'question')
-    documents = getattr(state,'messages')
-    generation = getattr(state,'generation')
+    question = state.get('question')
+    documents = state.get('messages')
+    generation = state.get('generation')
     llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
 
-    if getattr(state,'source') == "websearch":
+    if state.get('source') == "websearch":
         #print("---CHECK HALLUCINATIONS---")
         hallucination_grader_instance =  hallucination_grader(llm)
         #for output in hallucination_grader_instance.stream(
@@ -622,7 +624,7 @@ async def retrieve(
     configuration = AgentConfiguration.from_runnable_config(config)
 
     #print("---RETRIEVE---")
-    question = getattr(state,'question')
+    question = state.get('question')
 
     llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
 
@@ -646,7 +648,7 @@ async def retrieve(
     }
 
    # Retrieval
-    rag_input = int(getattr(state,'rag'))
+    rag_input = state.get('rag',1)
     retrieval_chain = await get_retrieval_chain(rag_input,"ea4all_agent",question,retriever, config=config)
    
     retrieved_documents = {
@@ -659,15 +661,15 @@ async def retrieve(
     
     documents = await final_chain.ainvoke({"user_question": question, "chat_memory":[]})
 
-    return {"messages": format_docs(documents['cdocs']), "question": question, "rag":getattr(state,'rag')}
+    return {"messages": format_docs(documents['cdocs']), "question": question, "rag":state.get('rag')}
 
 ### Edges ###
 def route_to_node(state:OverallState):
     
-    if state.source == "websearch":
+    if state.get('source') == "websearch":
         #print("---ROUTE QUESTION TO WEB SEARCH---")
         return "websearch"
-    elif state.source == "vectorstore":
+    elif state.get('source') == "vectorstore":
         #print("---ROUTE QUESTION TO RAG---")
         return "vectorstore"
 
@@ -701,10 +703,10 @@ async def stream_generation(
     source = None
     chat_memory = None
     async for s in state:
-        documents = getattr(s,"messages")
-        question = getattr(s,"question")
-        source = getattr(s,"source")
-        chat_memory = getattr(s,"chat_memory")
+        documents = s.get("messages")
+        question = s.get("question")
+        source = s.get("source")
+        chat_memory = s.get("chat_memory")
 
     # Prompt Web Search generation
     if source == "websearch":
@@ -743,14 +745,15 @@ async def generate(
     """
     #print("---GENERATE---")
 
-    #documents = getattr(state,'messages')[-1].content #documents
-    source = getattr(state,'source') 
-    #question = getattr(state,'question')
+    #documents = state.get('messages')[-1].content #documents
+    #source = state.get('source') 
+    #question = state.get('question')
+    source = state.get('source')
 
     ##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":
+    #if state.get('generation') is None:
+    #    if state.get('web_search') == "Yes":
     #        await websearch(state, config)
     #    else:
     #        state.rag = "1"
@@ -772,8 +775,8 @@ async def apm_agentic_qna(
 
     configuration = AgentConfiguration.from_runnable_config(config)
 
-    question = getattr(state,'question')
-    chat_memory = getattr(state,'chat_memory')
+    question = state.get('question')
+    chat_memory = state.get('chat_memory')
 
     llm = get_llm_client(model=configuration.query_model, api_base_url=configuration.api_base_url)
 
@@ -821,16 +824,16 @@ async def final(state: OverallState):
     return {"safety_status": state}
 
 async def choose_next(state: OverallState):
-    if state.safety_status is not None and len(state.safety_status) > 0 and state.safety_status[0] == 'no':
+    # Removed and len(state.get('safety_status')) > 0 
+    if state.get('safety_status') is not None and state.get('safety_status'[0]) == 'no':
         return "exit"
     else:
         return "route"
 
 class SafetyCheck:
-    def apm_safety_check(self,state: OverallState, config: RunnableConfig):
+    def apm_safety_check(self, question: str, config: RunnableConfig):
 
         configuration = AgentConfiguration.from_runnable_config(config)
-        question = state.question
 
         safety_prompt = pull('learn-it-all-do-it-all/ea4all_apm_safety_check')
 
@@ -853,15 +856,17 @@ class SafetyCheck:
         self._safety_run = self.apm_safety_check
 
     def __call__(self, state: OverallState, config: RunnableConfig) -> dict[str, list]:
+        question = state['messages'][-1].content
+
         try:
-            response = getattr(self, '_safety_run')(state, config)
-            return {"safety_status": [response['safety_status'][0], "", state.question]}
+            response = getattr(self, '_safety_run')(question, config)
+            return {"safety_status": [response['safety_status'][0], "", question], "question": [question]}
         except Exception as e:
-            return {"safety_status": ['no', e, state.question]}
+            return {"safety_status": ['no', e, question]}
 
 ##BUILD APM Graph
 # Build graph
-workflow = StateGraph(OverallState, input=InputState, output=OutputState, config_schema=AgentConfiguration)
+workflow = StateGraph(state_schema=OverallState, input_schema=InputState, output_schema=OutputState, config_schema=AgentConfiguration)
 
 # Define the nodes
 workflow.add_node("safety_check",SafetyCheck())
@@ -903,4 +908,4 @@ workflow.add_edge("final", END)
 
 # Compile
 apm_graph = workflow.compile()
-apm_graph.name = "APMGraph"
+apm_graph.name = "ea4all_talk_to_your_landscape"

ea4all/src/ea4all_apm/state.py

@@ -4,9 +4,9 @@ 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
+from langgraph.graph import MessagesState
 
 class Router(TypedDict):
     """Classify a user query."""
@@ -16,8 +16,7 @@ class Router(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:
+class InputState(MessagesState):
     """Represents the input state for the agent.
 
     This class defines the structure of the input state, which includes
@@ -27,20 +26,17 @@ class InputState:
     """
 
     """Attributes:
-        question: user question
+        message: user question
     """
-    question: str
+    pass
 
-@dataclass(kw_only=True)
-class OutputState:
+class OutputState(TypedDict):
     """Represents the output schema for the APM agent."""
     question: str
-    messages: Optional[List[str]] = None
-    generation: Optional[str] = None
-    source: Optional[str] = None
+    generation: Optional[str]
+    source: Optional[str]
     """Answer to user's Architecture IT Landscape question about ."""
 
-@dataclass(kw_only=True)
 class OverallState(InputState, OutputState):
     """State of the APM graph / agent."""
     
@@ -52,8 +48,8 @@ class OverallState(InputState, OutputState):
     rag: last RAG approach used
     chat_memory: user chat memory
     """
-    safety_status: Optional[Tuple[str, str, str]] = None
-    router: Optional[Router] = None
-    rag: Optional[str] = None
-    chat_memory: Optional[str] = None
-    retrieved: Optional[List[str]] = None
+    safety_status: Optional[Tuple[str, str, str]]
+    router: Optional[Router]
+    rag: Optional[str]
+    chat_memory: Optional[str]
+    retrieved: Optional[List[str]]

ea4all/src/ea4all_gra/configuration.py

@@ -25,7 +25,7 @@ class AgentConfiguration(BaseConfiguration):
     )
 
     recursion_limit: Annotated[int, {"__template_metadata__": {"kind": "integer"}}] = field(
-        default=10,
+        default=5,
         metadata={
             "description": "The maximum number of times the agent can recursively call itself."
         },
@@ -39,7 +39,7 @@ class AgentConfiguration(BaseConfiguration):
     )
 
     ea4all_ask_human: Annotated[str, {"__template_metadata__": {"kind": "integration"}}] = field(
-        default="Frontend",
+        default="frontend", #"interrupt", #
         metadata={
             "description": "Trigger EA4ALL ask human input via interruption or receive from external frontend."
         },

ea4all/src/ea4all_gra/graph.py

@@ -32,20 +32,23 @@ for required libraries and modules.
 - Refactored State classes to OverallState, InputState, OutputState
 - Task-1, Task-2, Task-3 State classes changed to TypedDicts
 - Review what's best content to provide Retrieve with requirements or intent
+#20250614
+- ask_human input changed to business_query from user_feedback key
+- enter_graph: (line 358) business_query = state.get('business_query') needs to be reviewed when using w/ Gradio (build & MCP versions)
+- assess_asis: 'Recursion limit of 25 reached without hitting a stop condition'
+#20250615
+- Recursion limit fixed w/ RemainingSteps, https://langchain-ai.github.io/langgraph/how-tos/graph-api/?h=remainingsteps
 """
 
-
 #core libraries
 from langchain_core.runnables import RunnableConfig
 from langchain_core.prompts.chat import ChatPromptTemplate, MessagesPlaceholder
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.messages import (
     AIMessage,
-    SystemMessage,
     HumanMessage,
 )
 from langchain_core.output_parsers import (
-    PydanticOutputParser, 
     JsonOutputKeyToolsParser
 )
 from langgraph.graph import (
@@ -53,7 +56,6 @@ from langgraph.graph import (
     StateGraph,
 )
 from langgraph.types import Command, interrupt
-from langgraph.checkpoint.memory import MemorySaver
 
 from langchain import hub
 
@@ -108,7 +110,7 @@ async def togaf_ask_human(state: OverallState, config: RunnableConfig):
 
         print(f"--- TOGAF AGENTIC team ---  got an answer and processing user input: {response}") 
 
-        business_query = load_mock_content(response['user_feedback'])
+        business_query = load_mock_content(response['business_query'])
     else:
         business_query = state.get('business_query')
 
@@ -251,7 +253,7 @@ def get_last_message(state: OverallState) -> dict:
 
 def join_graph(state: OverallState) -> dict:
     results = {}
-    results['messages'] = [state.get('business_query')[-1]]
+    #results['messages'] = [state.get('business_query')]
     results['next'] = state.get('next')
     if state.get('business_query'):
         results['business_query'] = state.get('business_query')
@@ -344,7 +346,9 @@ def return_2user(state:OverallState):
 
 async def enter_graph(state:dict, config: RunnableConfig) -> dict:
 
-    print(f"--- Entered TOGAF AGENTIC team to --- {state.get('business_query')}") #state.get('business_query')[-1].content
+    business_query = state['messages'][-1].content if not isinstance(state['messages'][-1].content, List) else state['messages'][-1].content[0]['text']
+    
+    print(f"--- Entered TOGAF AGENTIC team to --- {business_query}") #state.get('business_query')[-1].content
     #if isinstance(state, dict):
     #    user_feedback = state.get('user_feedback') if state.get('user_feedback') else state['messages'][-1].content
     #else:
@@ -352,7 +356,8 @@ async def enter_graph(state:dict, config: RunnableConfig) -> dict:
     
     #busines_query = load_mock_content(state.get('user_feedback')),
 
-    business_query = state['business_query'][-1]['content']
+    #business_query = state.get('business_query')
+    #business_query = state['business_query'][-1]['content']
 
     return {"business_query": business_query}
 
@@ -407,4 +412,4 @@ workflow.set_entry_point("enter_graph")
 
 #memory = MemorySaver()
 togaf_graph = workflow.compile() #checkpointer=memory)
-togaf_graph.name = "Togaf_reference_architecture_graph"
+togaf_graph.name = "ea4all_architecture_blueprint"

ea4all/src/ea4all_gra/state.py

@@ -1,16 +1,15 @@
-from pydantic import Field
 from typing_extensions import (
-    Annotated,
     TypedDict,
     List
 )
-import operator
 from typing import (
     Optional,
 )
 from dataclasses import dataclass, field
 from typing import Optional
 
+from langgraph.graph import MessagesState
+
 from ea4all.src.ea4all_gra.data import (
     ListRequirement, 
     ListObjective, 
@@ -25,8 +24,7 @@ from ea4all.src.ea4all_gra.data import (
 # Optional, the InputState is a restricted version of the State that is used to
 # define a narrower interface to the outside world vs. what is maintained
 # internally.
-@dataclass(kw_only=True)
-class InputState(TypedDict):
+class InputState(MessagesState):
     """Represents the input state for the agent.
 
     This class defines the structure of the input state, which includes
@@ -40,9 +38,9 @@ class InputState(TypedDict):
     """
     #business_query: Optional[Annotated[List[str], Field(
     #    description="A business requirement is the starting point of the TOGAF process."), operator.add]] 
-    business_query: str
+    #business_query: str
+    pass
 
-@dataclass(kw_only=True)
 class OutputState(TypedDict):
     """Represents te output state for the agent."""
     vision_target: Optional[str]
@@ -72,6 +70,7 @@ class OverallState(InputState, OutputState):
     - next (Optional[str]): Represents the next step in the Togaf system.
     """
 
+    business_query: str
     query_status: Optional[bool]
     stakeholder: Optional[StakeholderList]
     principles: Optional[Principles]

ea4all/src/ea4all_gra/togaf_task1/graph.py

@@ -122,4 +122,4 @@ task1_builder.set_finish_point('AssessBusinessQuery')
 
 # Compile
 task1_graph = task1_builder.compile()
-task1_graph.name = "togaf_assess_business_query_graph"
+task1_graph.name = "togaf_identify_business_requirements"

ea4all/src/ea4all_gra/togaf_task1/state.py

@@ -43,7 +43,8 @@ class Task1State(InputState):
         capability: list of business capabilities to deliver intent and requirements
     """
 
-    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    #messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    business_query: str
     team_members: Optional[List[str]]
     requirement: Optional[ListRequirement]
     intent: Optional[ListObjective]

ea4all/src/ea4all_gra/togaf_task2/graph.py

@@ -1,7 +1,7 @@
 import ast
 
 #core libraries
-from langchain_core.runnables import RunnableConfig, RunnableSerializable
+from langchain_core.runnables import RunnableConfig
 
 from langchain_core.messages import (
     AIMessage,
@@ -42,9 +42,6 @@ from ea4all.src.shared import vectorstore
 from ea4all.src.ea4all_gra.togaf_task2.state import Task2State
 
 from ea4all.src.ea4all_apm.graph import get_retrieval_chain
-from ea4all.src.ea4all_apm import configuration as apm_config
-
-from ea4all.src.ea4all_gra.state import OverallState
 
 # Retrieval Grader score whether retrieved IT Landscape  address business query
 def retrieval_grader(model):
@@ -145,7 +142,6 @@ async def retrieve(state:Task2State, config: RunnableConfig):
 
     # Retrieval
     rag_input = 5
-    #faiss_index = set_faiss_index(config)
     with vectorstore.make_retriever(config) as _retriever:
         retriever = _retriever
 
@@ -155,13 +151,15 @@ async def retrieve(state:Task2State, config: RunnableConfig):
         {"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)
+
+    name = state['next']
+
+
     return {
         "messages": [AIMessage(content=content, name=name)],
-        "landscape_asis": landscape_asis, 
+        "landscape_asis": landscape_asis,
         "business_query": business_query
     }
 
@@ -324,6 +322,8 @@ def grade_generation_v_documents_and_question(state:Task2State, config: Runnable
     configuration = AgentConfiguration.from_runnable_config(config)
     model = get_llm_client(configuration.togaf_model, configuration.api_base_url)
 
+    if state.get('remaining_steps') <= 2:
+        return "no match"
 
     print("---CHECK HALLUCINATIONS---")
     business_query = state['business_query']
@@ -393,10 +393,7 @@ def grade_landscape_asis_v_capability_gap(state:Task2State, config: RunnableConf
         content = "No applications identified"
 
     if state['biz_capability']:
-        capability = ', '.join(ast.literal_eval(state['biz_capability'])).replace("'", ", ")
-        #bcm = ast.literal_eval(str(state['biz_capability']))
-        #capability = bcm[1:-1].replace("'","")
-        #capability = state['biz_capability']
+        capability = ', '.join(ast.literal_eval(str(state['biz_capability']))).replace("'", ", ")
     else:
         capability = "No business capabilities identified"
     
@@ -447,6 +444,7 @@ task2_builder.add_conditional_edges(
         "not supported": "generate",
         "useful": "grade_landscape_gap",
         "not useful": "transform_query",
+        "no match": "grade_landscape_gap"
     },
 )
 
@@ -454,4 +452,4 @@ task2_builder.add_edge("grade_landscape_gap", END)
 
 # Compile
 task2_graph = task2_builder.compile()
-task2_graph.name = "Togaf_assess_asis_graph"
+task2_graph.name = "togaf_assess_current_landscape"

ea4all/src/ea4all_gra/togaf_task2/state.py

@@ -16,6 +16,8 @@ from langchain_core.messages import (
 
 from langchain_core.documents import Document
 
+from langgraph.managed.is_last_step import RemainingSteps
+
 from ea4all.src.ea4all_gra.data import (
     BusinessCapability, 
     CapabilityGap,
@@ -41,10 +43,13 @@ class Task2State(InputState):
         landscape_gap: business capability support gap
     """
     
-    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    #messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    business_query: str
     team_members: Optional[List[str]]
     landscape_asis: Optional[List[Document]]
     identified_asis: Optional[LandscapeAsIs]
     biz_capability: Optional[BusinessCapability]
     landscape_gap: Optional[CapabilityGap]
     next: Optional[str]
+    remaining_steps: RemainingSteps
+

ea4all/src/ea4all_gra/togaf_task3/graph.py

@@ -244,4 +244,4 @@ workflow.set_entry_point("generate_reference_architecture")
 
 # Compile
 task3_graph = workflow.compile()
-task3_graph.name = "Togaf_generate_tobe_graph"
+task3_graph.name = "togaf_generate_blueprint"

ea4all/src/ea4all_gra/togaf_task3/state.py

@@ -49,7 +49,8 @@ class Task3State(InputState):
         landscape_gap: list of capabilities not supported by as-is landscape
     """
 
-    messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    #messages: Optional[Annotated[Sequence[BaseMessage], operator.add]]
+    business_query: str
     team_members: Optional[List[str]]
     landscape_asis: Optional[List[str]]
     identified_asis: Optional[LandscapeAsIs]

ea4all/src/ea4all_indexer/graph.py

@@ -54,4 +54,4 @@ 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"
+indexer_graph.name = "ea4all_bring_your_onw_data"

ea4all/src/ea4all_mcp/configuration.py

@@ -0,0 +1,21 @@
+"""Define the configurable parameters for the graph."""
+
+from dataclasses import dataclass, field
+from typing import Annotated
+
+from ea4all.src.shared.configuration import BaseConfiguration
+
+@dataclass(kw_only=True)
+class AgentConfiguration(BaseConfiguration):
+    """Configuration class.
+    """
+    mcp_docs_model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="gpt-4o-mini",
+        metadata={
+            "description": "The language model used by ea4all_aws_ms react agent."
+        },
+    )
+
+    
+
+    pass

ea4all/src/ea4all_mcp/graph.py

@@ -0,0 +1,97 @@
+"""
+graph.py - MCP Agent Graph for AWS and Microsoft Documentation
+
+This module defines the LangGraph agent for the MCP (Multi-Cloud Platform) assistant,
+enabling intelligent routing and answering of queries related to AWS and Microsoft technologies.
+
+Key Features:
+- Integrates with AWS and Microsoft MCP servers for documentation and diagram generation.
+- Dynamically loads available tools from both AWS and Microsoft MCP endpoints.
+- Provides a unified agent that can answer questions about AWS services, Microsoft technologies, and generate AWS diagrams.
+- Uses OpenAI GPT-4o-mini as the LLM backend for reasoning and tool selection.
+- Returns expert-level answers or defers when information is insufficient.
+
+Main Functions:
+- load_tools(): Asynchronously loads tool definitions from AWS and Microsoft MCP servers.
+- build_graph(): Constructs and returns the LangGraph agent configured with the appropriate tools and system prompt.
+
+Intended Usage:
+Import and call `build_graph()` to obtain a ready-to-use agent for enterprise architecture, cloud, and documentation queries.
+
+References:
+- [AWS MCP Servers](https://github.com/awslabs/mcp/tree/main/src)
+- [MicrosoftDocs MCP Server](https://github.com/microsoftdocs/mcp)
+"""
+import asyncio
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+
+from ea4all.src.ea4all_mcp.configuration import AgentConfiguration
+from ea4all.src.ea4all_mcp.prompts import MCP_AWS_MS_SYSTEM_PROMPT
+
+from ea4all.src.shared.utils import (
+    get_llm_client, 
+)
+
+async def load_tools():
+    # Set up the MCP client for AWS Documentation
+    mcp_client = MultiServerMCPClient(
+        {
+            "awslabs.aws-documentation-mcp-server": {
+                "transport": "stdio",
+                "command": "uvx",
+                "args": ["awslabs.aws-documentation-mcp-server@latest"],
+                "env": {
+                    "FASTMCP_LOG_LEVEL": "ERROR",
+                    "AWS_DOCUMENTATION_PARTITION": "aws"
+                },
+                "disabled": False,
+                "autoApprove": [],
+            },
+            "awslabs.aws-diagram-mcp-server": {
+                "transport": "stdio",
+                "command": "uvx",
+                "args": ["awslabs.aws-diagram-mcp-server"],
+                "env": {
+                    "FASTMCP_LOG_LEVEL": "ERROR"
+                },
+                "autoApprove": [],
+                "disabled": False
+            },
+            "microsoft_mcp_tools": {
+                "url": "https://learn.microsoft.com/api/mcp",
+                "transport": "streamable_http",
+            }
+        }
+    )
+
+    # Fetch the tools from the AWS MCP server
+    mcp_tools = await mcp_client.get_tools()
+
+    return mcp_tools
+
+async def build_graph():
+    """Build the LangGraph graph for the MCP agent."""
+    # Define the graph structure
+    system_prompt = """
+    """
+
+    mcp_tools = await load_tools()
+    
+    llm = get_llm_client(model=AgentConfiguration.mcp_docs_model)
+
+    # Create the LangGraph agent for AWS documentation
+    ea4all_docs = create_react_agent(
+        model=llm,
+        prompt=MCP_AWS_MS_SYSTEM_PROMPT,
+        tools=mcp_tools,
+        debug=True,
+        #state_schema=OverallState,
+    )
+
+    ea4all_docs.name = "ea4all_mcp_aws_microsoft_docs_agent"
+
+    return ea4all_docs
+
+mcp_docs_graph = asyncio.run(build_graph())

ea4all/src/ea4all_mcp/prompts.py

@@ -0,0 +1,15 @@
+################################
+##COLLECTION of MCP react_agents system prompt
+################################
+
+##AWS & Microsoft Documentation system prompt
+MCP_AWS_MS_SYSTEM_PROMPT = """
+## Querying Microsoft Documentation, AWS Documentation, and AWS Diagram Generation
+You have access to the following MCP server
+#1 `microsoft_mcp_tools` - this tool allows you to search through Microsoft's latest official documentation, and that information might be more detailed or newer than what's in your training data set.
+When handling questions around how to work with native Microsoft technologies, such as C#, F#, ASP.NET Core, Microsoft.Extensions, NuGet, Entity Framework, the `dotnet` runtime - please use this tool for research purposes when dealing with specific / narrowly defined questions that may occur.
+#2 `awslabs.aws-diagram-mcp-server` - this tool allows you to generate AWS diagrams, sequence diagrams, flow diagrams, and class diagrams.
+#3 `awslabs.aws-documentation-mcp-server` - this tool allows you to search through AWS's latest official documentation, which may be more up-to-date than your training data. For any questions about AWS products, services, APIs, or best practices, use this tool to provide accurate and current information.
+
+For any other questions,  reply with "Hey, I am an expert assistant on AWS and Microsoft! I don't know or I don't have enough information to answer that question.
+"""

ea4all/src/ea4all_mcp/state.py

@@ -0,0 +1,29 @@
+"""State management for the MCP graph."""
+from typing_extensions import TypedDict
+
+from langgraph.prebuilt.chat_agent_executor import AgentState
+
+class InputState(TypedDict):
+    """Represents the input state for the graph.
+
+    This class is used to pass the user question to the graph.
+    It contains a single field, `question`
+    """
+
+    pass
+
+# The index state defines the simple IO for the single-node index graph
+class OutputState(TypedDict):
+    """Represents the output schema for the graph.
+    """
+
+    pass
+
+class OverallState(AgentState, InputState, OutputState):
+    """Represents the overall state of the graph.
+
+    This class combines the input and output states, allowing for
+    both input and output to be managed within
+    the same state.
+    """
+    pass

ea4all/src/ea4all_vqa/configuration.py

@@ -40,3 +40,10 @@ class AgentConfiguration(BaseConfiguration):
             "description": "Trigger EA4ALL ask human input via interruption or receive from external frontend."
         },
     )
+
+    vqa_images: Annotated[list[str], {"__template_metadata__": {"kind": "file"}}] = field(
+        default_factory=lambda: [".png"],
+        metadata={
+            "description": "List of image files to be used for visual question and answering. Should be in the form: [\"path/to/image2.png\"]."
+        },
+    )

ea4all/src/ea4all_vqa/graph.py

@@ -60,8 +60,6 @@ from ea4all.src.shared.utils import (
     _join_paths,
 )
 
-import spaces
-
 ##Diagram Graph Tools 
 #Data model Sageguarding
 @tool("diagram_safeguard")
@@ -72,8 +70,8 @@ class DiagramV2S(BaseModel):
     description: str = Field(description="One sentence describing the reason for being categorised as unsafe or not an architecture image.")
 
 @tool("vqa_diagram", response_format="content")
-@spaces.GPU
-async def vqa_diagram(next:str, state: Annotated[OverallState, InjectedState], config: RunnableConfig):
+#@spaces.GPU
+async def vqa_diagram(next:str, state: Annotated[InputState, InjectedState], config: RunnableConfig):
     """Diagram Vision Question Answering"""
 
     print(f"---AGENT VQA PROCESSING QUESTION & ANSWERING---")
@@ -86,8 +84,9 @@ async def vqa_diagram(next:str, state: Annotated[OverallState, InjectedState], c
         streaming=configuration.streaming, 
     )
 
-    question = getattr(state, "question")
-    raw_image = get_raw_image(getattr(state,'image'))
+    #question = state.get('question')
+    question = state.get('messages')[0].content
+    raw_image = get_raw_image(state.get('image'))
 
     user_message = HumanMessage(
             content=[
@@ -168,8 +167,8 @@ def safeguard_check(state:OverallState, config:RunnableConfig) -> dict:
     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')))
+    question = state.get('question')
+    raw_image = get_raw_image(state.get('image', _join_paths(configuration.ea4all_images,'multi-app-architecture.png')))
 
     system_message = (
     "Act as a safeguarding agent to check whether the image provided is an architecture diagram or flowchart and safe to be processed. "
@@ -193,7 +192,8 @@ def safeguard_check(state:OverallState, config:RunnableConfig) -> dict:
     input = {"question": question, "raw_image": raw_image}
     result = safeguard_checker.invoke(input=input, config=config)
     
-    return {"safety_status": result}
+    #return Command(update={"safety_status": result, "question": question})
+    return {'safety_status': result}
 
 def call_finish(state:OverallState, config:RunnableConfig) -> dict:
 
@@ -209,7 +209,7 @@ def make_supervisor_node(model: BaseChatModel, members: list[str]) -> RunnableLa
         "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'."
+        " If none of team member can be used or task has been completed select 'FINISH'."
     )
 
     class Router(TypedDict):
@@ -221,13 +221,14 @@ def make_supervisor_node(model: BaseChatModel, members: list[str]) -> RunnableLa
         """An LLM-based router."""
         messages = [
             {"role": "system", "content": system_prompt},
-        ] + getattr(state, 'messages')
+        ] + (state.get('messages') or [])
         
         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 response['parsed']['next'] == "FINISH":
+                output = state['messages'][-1].content if state['messages'][-1].type == 'tool' and state['messages'][-1].status == 'success' else response['raw']
+                return AgentFinish(return_values={"output": response['raw'].content}, log=str(output))
 
             # 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"}
@@ -294,7 +295,7 @@ def create_team_supervisor(state:OverallState, config:RunnableConfig) -> Runnabl
     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}))
+    llm.max_tokens = set_max_new_tokens(get_predicted_num_tokens_from_prompt(llm, prompt, {"question":state.get('question')}))
 
     supervisor_agent = (
         prompt | 
@@ -311,41 +312,28 @@ def enter_graph(state:OverallState, config:RunnableConfig) -> Command[Literal['s
 
     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')
+    raw_image = state.get('image', _join_paths(configuration.ea4all_images,'multi-app-architecture.png'))
+    question = state['messages'][-1].content if state['messages'] else "Describe the image"
 
     return Command(
         update={
-            "messages": messages,
-            "question": state.question, #messages[-1].content,
+            "messages": state['messages'][-1],
+            "question": question,
             "image": raw_image
         },
         goto='safeguard_check',
     )
 
-    return {
-        "messages": state.messages,
-        "question": messages[-1].content,
-        "image": raw_image,
-    }
-
 async def choose_next(state: OverallState):
     """Choose the next node based on the safety status."""
-    isArcihitectureImage = getattr(state, 'safety_status', {}).get('isArchitectureImage', False)
-    isSafe = getattr(state, 'safety_status', {}).get('isSafe', False)
+    isArcihitectureImage = ''
+    isSafe = ""
+
+    safety_status = state.get('safety_status', {})
+
+    if safety_status:
+        isArcihitectureImage = safety_status.get('isArchitectureImage', False)
+        isSafe = safety_status.get('isSafe', False)
 
     return "diagram_supervisor" if isArcihitectureImage and isSafe else "final"
 
@@ -353,7 +341,7 @@ 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
+    workflow = StateGraph(OverallState, input_schema=InputState, output_schema=OutputState,config_schema=AgentConfiguration) #input=InputState
 
     #Setup Graph nodes
     #Node name CANNOT have blank space - pattern: \'^[a-zA-Z0-9_-]+$\'.", \'type\'
@@ -390,11 +378,11 @@ def build_vqa_graph():
     )
 
     workflow.add_edge("final", END)
-    workflow.add_edge("tools", END)
+    workflow.add_edge("tools", "diagram_supervisor")
 
     #memory = MemorySaver()
     diagram_graph = workflow.compile() #checkpointer=memory)
-    diagram_graph.name = "DiagramGraph"
+    diagram_graph.name = "ea4all_talk_to_your_diagram"
 
     return diagram_graph
 

ea4all/src/ea4all_vqa/state.py

@@ -3,25 +3,24 @@
 This module defines the state structures used in the VQA graph. It includes
 definitions for agent state, input state.
 """
+from typing_extensions import TypedDict, NotRequired
 
-import operator
 from dataclasses import dataclass
 from typing import (
     Optional,
     Annotated, 
-    Sequence,
 )
 
-from langchain_core.messages import (
-    BaseMessage,
-)
+from langchain_core.messages import AnyMessage
+from langgraph.graph.message import add_messages
 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:
+#@dataclass(kw_only=True)
+class InputState(MessagesState):
     """Represents the input state for the agent.
 
     This class defines the structure of the input state, which includes
@@ -34,17 +33,16 @@ class InputState:
         question: user question
         image: architecture diagram
     """
-    question: str
-    image: str
+    image: NotRequired[str]
 
 # The index state defines the simple IO for the single-node index graph
-@dataclass(kw_only=True)
-class OutputState:
+#@dataclass(kw_only=True)
+class OutputState(TypedDict):
     """Represents the output schema for the Diagram agent.
     """
-
-    messages: Optional[Annotated[Sequence[MessagesState], operator.add]] = None
-    safety_status: Optional[dict[str,str]] = None
+    safety_status: dict[str,str]
+    question: str
+    messages: Annotated[list[AnyMessage], add_messages]
 
     """Attributes:
     safety_status: safety status of the diagram provided by the user
@@ -60,5 +58,5 @@ class OverallState(InputState, OutputState):
     next: next tool to be called
     """
     
-    error: Optional[str] = None
-    next: Optional[str] = None
+    error: NotRequired[str]
+    next: NotRequired[str]

ea4all/src/graph.py

@@ -22,15 +22,43 @@ Note: This module depends on other modules and packages such as langchain_core,
 - 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)
+#2025-06-13
+– Deployed to ea4all-langgraph-lgs
+- Renamed graphs: after removing .langgraph_api folder the errors caused by old-graph names being still exposed was FIXED.
+#20250624
+- Retrofitted StateGraph to use OverallState, InputState, and OutputState
+#20250626
+- Call_generate_websearch State dict updated to match APMGraph OverallState
+#20250627
+- Diagram graph invoke returning empty message - fixed 30-Jun
+#20250707
+- AgentState refactored to OverallState, InputState, and OutputState
+- Microsoft and AWS MCP tools added to the EA4ALL Agentic Workflow Graph
+#20250717
+- AgentState class is exclusively used for React Agent
+#20250718
+- Refactored super graph InputState as MessagesState schema and OutputState with question attribute
+- Refactored websearch & apm_grap to MessagesState
+- get_llm_client updated with new HF Inference API endpoint https://router.huggingface.co/v1
+- ISSUE: APM Graph not passing internally the Question attribute coming from the Supervisor Node - fixed
+#20250719
+- Refactored ea4all_vqa to use MessagesState
+- Added extracted_and_validated_path function to utils.py for extracting and validating file paths from user input
+- ISSUE: VQA Diagram not returning response but safety_check status only
+#20250720
+- Refactored ea4all_mcp to use standard AgentState state schema as react_agent does not use InputState schema
+- ISSUE: VQA Diagram not returning response but safety_check status only - fixed
+-- Re-added messages attribute to OutputState schema
+-- Response added to AgentFinish log
 """
 
 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_core.messages import HumanMessage
 
 from langchain import hub
 
@@ -39,22 +67,22 @@ from langgraph.graph import (
     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.shared.utils import get_llm_client, extract_text_from_message_content, extract_and_validate_path
+from ea4all.src.shared.state import InputState, OutputState, OverallState
 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
+from ea4all.src.ea4all_mcp.graph import mcp_docs_graph
 
-async def call_indexer_apm(state: State, config: RunnableConfig):
+async def call_indexer_apm(state: OverallState, config: RunnableConfig):
     response = await indexer_graph.ainvoke(input={"docs":[]}, config=config)
 
 def make_supervisor_node(model: BaseChatModel, members: list[str]):
@@ -64,36 +92,37 @@ def make_supervisor_node(model: BaseChatModel, members: list[str]):
 
     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"]
+        next: Literal["FINISH", "portfolio_team", "diagram_team", "blueprint_team", "websearch_team", "mcp_docs_team"]
 
-    async def supervisor_node(state: State, config: RunnableConfig) -> Command[Literal["portfolio_team", "diagram_team", "blueprint_team", "websearch_team", '__end__']]:
+    async def supervisor_node(state: OverallState, config: RunnableConfig) -> Command[Literal["portfolio_team", "diagram_team", "blueprint_team", "websearch_team", "mcp_docs_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)
+        messages.append({"role": "user", "content": state['messages'][-1].content})
+       
+        response = await model.with_structured_output(Router).ainvoke(input=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"]:
+            if _goto not in ["portfolio_team", "diagram_team", "blueprint_team", "websearch_team", "mcp_docs_team"]:
                 _goto = "__end__"
 
-        print(f"---Supervisor got a request--- Question: {state['messages'][-1].content} ==> Routing to {_goto}\n")
+        question = extract_text_from_message_content(state['messages'][-1].content)
+        print(f"---Supervisor got a request--- Question: {question} ==> Routing to {_goto}\n")
 
-        return Command(
-                #update={"next": _goto}, 
-                goto=_goto
-                )
+        return Command(update={'question':question}, 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)
+async def call_landscape_agentic(state: OverallState, config: RunnableConfig) -> Command[Literal['__end__']]: ##2025-02-21: NOT passing CHAT MEMORY to the APM_graph
+    
+    response = await apm_graph.ainvoke(state, config=config)
     return Command(
         update={
             "messages": [
@@ -105,33 +134,50 @@ async def call_landscape_agentic(state: State, config: RunnableConfig) -> Comman
         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
+async def call_diagram_agentic(state: OverallState, config: RunnableConfig) -> Command[Literal['__end__']]: #NOT passing CHAT MEMORY to the Diagram_graph
+    from ea4all.src.ea4all_vqa.configuration import AgentConfiguration
+    from ea4all.src.ea4all_vqa.state import InputState
 
-    response = await diagram_graph.ainvoke(
-        input=inputs,
-        config=config
-    )
+    image_files = AgentConfiguration.from_runnable_config(config).vqa_images
+    user_input = extract_and_validate_path(text=state.get('question'), allowed_extensions=image_files)
+
+    if user_input['found'] and user_input['is_file']:            
+        inputs = InputState(
+            #question=user_input['message'],
+            messages=[HumanMessage(content=user_input['message'])],
+            image=user_input['path']
+        )
+
+        response = await diagram_graph.ainvoke(
+            input=inputs,
+            config=config
+        )
+        msg = response['messages'][-1].content if response['messages'] and hasattr(response['messages'][-1], 'content') else "No valid response from Diagram agentic graph."
+    else:
+        msg = f"No valid image file provided. Please provide one of the accepted file types: {image_files}."
 
     return Command(
         update={
             "messages": [
                 AIMessage(
-                    content=response['messages'][-1].content, name="landscape_agentic"
+                    content=msg, name="diagram_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}")
+async def call_togaf_agentic(state: OverallState, 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 {getattr(state, 'next')} with User Question: {getattr(state, 'question')}")
 
-    inputs = {"messages": [{"role": "user", "content": state.get('messages')[-1].content}]} #user response
+    inputs = {
+        "messages": [
+            {
+                "role": "user", 
+                "content": getattr(state, "question")[-1].content
+            }
+        ]
+    } #user response
 
     response = await togaf_graph.ainvoke(
         input=inputs, 
@@ -142,7 +188,7 @@ async def call_togaf_agentic(state: State, config: RunnableConfig) -> Command[Li
         update={
             "messages": [
                 AIMessage(
-                    content=response["messages"][-1].content, name="togaf_route"
+                    content=response["messages"][-1].content, name="togaf_agentic"
                 )
             ]
         },
@@ -150,18 +196,19 @@ async def call_togaf_agentic(state: State, config: RunnableConfig) -> Command[Li
     )
 
 # Wrap-up websearch answer to user's question
-async def call_generate_websearch(state:State, config: RunnableConfig) -> Command[Literal["__end__"]]:
+async def call_generate_websearch(state:OverallState, config: RunnableConfig) -> Command[Literal["__end__"]]:
     from ea4all.src.ea4all_apm.state import OverallState
 
     if config is not None:
         source = config.get('metadata', {}).get('langgraph_node', 'unknown')
 
     # Invoke GENERATOR node in the APMGraph
+    messages = state.get('messages')
+    last_message_content = messages[-1].content if messages and hasattr(messages[-1], "content") else ""
     state_dict = {
-        "documents": state['messages'][-1].content,
-        "web_search": "Yes",
-        "question": state['messages'][-2].content,
-        "source": source
+        "messages": last_message_content,
+        "source": "websearch",
+        "question": state.get('question'),
     }
 
     apm_state = OverallState(**state_dict)
@@ -178,17 +225,54 @@ async def call_generate_websearch(state:State, config: RunnableConfig) -> Comman
         goto="__end__",
     )
 
-async def blueprint_team(state: State) -> Command[Literal["togaf_route"]]:
+async def blueprint_team(state: OverallState) -> 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"]]:
+async def diagram_team(state: OverallState) -> 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):
+async def mcp_docs_team(state: OverallState) -> Command[Literal["__end__"]]:
+    print("---MCP Docs team got a request--- Routing to MCP_DOCS_AGENTIC node")
+
+    # Invoke the EA4ALL MCP Docs graph
+    mcp_response = await mcp_docs_graph.ainvoke(
+        {"messages": [{"role": "user", "content": state.get('question')}]}
+    )
+
+    return Command(
+        update={
+            "messages": [
+                AIMessage(
+                    content=mcp_response['messages'][-1].content, name="mcp_docs_agentic"
+                )
+            ]
+        },
+        goto="__end__",
+    )
+
+async def call_websearch(state: OverallState, config: RunnableConfig) -> Command[Literal["generate_websearch"]]:
+    """
+    Web search based on the re-phrased question.
+    
+    Args:
+        state (OverallState): The current graph state
+        config (RunnableConfig): Configuration with the model used for query analysis.
+    
+    Returns:
+        Command: Command to route to the generate_websearch node.
+    """
+    print(f"---Websearch team got a request--- Routing to GENERATE_WEBSEARCH node with User Question: {state.get('question')}")
+    
+    _state = dict(state)
+    response = await websearch(_state)
+
+    return Command(update=response, goto="generate_websearch")
+
+async def super_graph_entry_point(state: OverallState):
     # Generate a unique thread ID
     thread_config = RunnableConfig({"configurable": {"thread_id": str(uuid.uuid4())}})
     
@@ -219,18 +303,18 @@ 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 = StateGraph(state_schema=OverallState, input_schema=InputState, output_schema=OutputState, 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("websearch_team", call_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_node("mcp_docs_team", mcp_docs_team)
 
     super_builder.add_edge(START, "apm_indexer")
     super_builder.add_edge("apm_indexer", "supervisor")
@@ -243,10 +327,10 @@ def build_super_graph():
     super_builder.add_edge("generate_websearch", END)
     super_builder.add_edge("togaf_route", END)
     super_builder.add_edge("diagram_route", END)
+    super_builder.add_edge("mcp_docs_team", 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"
+    super_graph = super_builder.compile()
+    super_graph.name = "ea4all_supervisor"
 
     return super_graph
 

ea4all/src/shared/configuration.py

@@ -31,7 +31,7 @@ class BaseConfiguration:
     )
 
     api_base_url: Annotated[str, {"__template_metadata__": {"kind": "hosting"}}] = field(
-        default="https://api-inference.huggingface.co/models/",
+        default="https://router.huggingface.co/v1", #"https://api-inference.huggingface.co/models/",
         metadata={
             "description": "The base url for models hosted on Hugging Face's model hub."
         },
@@ -80,7 +80,7 @@ class BaseConfiguration:
     )
 
     ea4all_recursion_limit: Annotated[int, {"__template_metadata__": {"kind": "graph"}}] = field(
-        default=25,
+        default=5,
         metadata={
             "description": "Maximum recursion allowed for EA4ALL graphs."
         },

ea4all/src/shared/prompts.py

@@ -71,7 +71,7 @@ def ea4all_chat_prompt(template):
 
 ##select best prompt based on user inquiry's category
 @traceable(
-    tags={os.environ["EA4ALL_ENV"]}
+    tags=[os.getenv("EA4ALL_ENV", "build")]
 )
 def ea4ll_prompt_selector(category):
     QUESTION_PROMPT_SELECTOR = ConditionalPromptSelector(

ea4all/src/shared/state.py

@@ -2,13 +2,27 @@
 
 import hashlib
 import uuid
-from typing import Any, Literal, Optional, Union
+from typing import (
+    Any, 
+    Literal, 
+    Union,
+    Optional,
+    Annotated
+)
+from typing_extensions import TypedDict
 
+from langgraph.graph.message import add_messages
 from langgraph.graph import MessagesState
 from langchain_core.documents import Document
 
-class State(MessagesState):
+class InputState(MessagesState):
+    pass
+
+class OutputState(TypedDict):
+    question: str
     next: Optional[str]
+
+class OverallState(InputState, OutputState):
     user_feedback: Optional[str]
 
 def _generate_uuid(page_content: str) -> str:

ea4all/src/shared/utils.py

@@ -14,7 +14,9 @@ from dotenv import load_dotenv, find_dotenv
 import markdown
 from markdownify import markdownify as md2text
 from io import BytesIO
-import pandas as pd
+import string
+from typing import List, Dict, Optional
+
 
 from pydantic import BaseModel, SecretStr
 
@@ -175,7 +177,7 @@ def get_llm_client(model, api_base_url=None,temperature=0, streaming=False, toke
         client = ChatOpenAI(
             model=model,
             api_key=SecretStr(os.environ['HUGGINGFACEHUB_API_TOKEN']),
-            base_url=_join_paths(api_base_url, model, "v1/"),
+            base_url=api_base_url, #_join_paths(api_base_url, model, "v1/"),
             temperature=temperature,
             streaming=streaming,
             max_completion_tokens=tokens,
@@ -485,3 +487,85 @@ def get_relevant_questions(source: str) -> list:
     for line in mock.splitlines(): relevant_questions += [line]
 
     return relevant_questions
+
+def extract_text_from_message_content(content):
+    # content is expected to be a list of dicts with 'type' and 'text' keys
+    if isinstance(content, list):
+        texts = [part['text'] for part in content if part.get('type') == 'text']
+        return " ".join(texts)
+    # fallback if content is just a string
+    elif isinstance(content, str):
+        return content
+    else:
+        return ""
+    
+def extract_and_validate_path(
+    text: str, 
+    allowed_extensions: Optional[List[str]] = None
+) -> Dict:
+    """
+    Extracts the first valid file path or filename from text based on a list
+    of allowed extensions, validates its existence, and returns detailed info.
+
+    Args:
+        text: The input string to search for a path.
+        allowed_extensions: A list of allowed extensions (e.g., ['.png', '.csv']).
+                            If None, finds any path-like string.
+
+    Returns:
+        A dictionary containing the results.
+    """
+    path_str = None
+    msg_str = None
+    for word in text.split():
+        # Clean trailing punctuation (like a comma or question mark)
+        cleaned_word = word.rstrip(string.punctuation)
+
+        # A word is a candidate if it contains a path separator or a file extension dot.
+        is_candidate = '/' in cleaned_word or '.' in os.path.basename(cleaned_word)
+
+        if is_candidate:
+            # If a whitelist of extensions is provided, the candidate MUST match.
+            if allowed_extensions:
+                basename = os.path.basename(cleaned_word)
+                _, extension = os.path.splitext(basename)
+                
+                # Check if the extracted extension is in the allowed list (case-insensitive)
+                if extension.lower() in [ext.lower() for ext in allowed_extensions]:
+                    path_str = cleaned_word
+                    break  # Found a valid file, stop searching.
+            else:
+                # No whitelist, so the first candidate is our match.
+                path_str = cleaned_word
+                break
+        else:
+            # If the word is not a candidate, it might be part of a message.
+            if msg_str is None:
+                msg_str = word
+            else:
+                msg_str += ' ' + word
+    
+    if not path_str:
+        return {'found': False}
+
+    # --- If a path was found, gather all details ---
+    basename = os.path.basename(path_str)
+    dirname = os.path.dirname(path_str)
+    _, extension = os.path.splitext(basename)
+
+    # Filesystem validation
+    path_exists = os.path.exists(path_str)
+    is_file = os.path.isfile(path_str)
+    is_dir = os.path.isdir(path_str)
+
+    return {
+        'found': True,
+        'path': path_str,
+        'dirname': dirname if dirname else ('/' if path_str.startswith('/') else '.'),
+        'basename': basename,
+        'extension': extension,
+        'exists': path_exists,
+        'is_file': is_file,
+        'is_dir': is_dir,
+        'message': msg_str if msg_str else None
+    }

ea4all/src/tools/tools.py

@@ -1,5 +1,6 @@
-from typing import Literal, Annotated
-from typing_extensions import TypedDict
+from typing import Literal
+from typing_extensions import TypedDict, Literal as ExtLiteral
+
 import json
 import tempfile
 import os
@@ -8,20 +9,17 @@ from langchain_core.runnables import RunnableLambda, RunnableConfig
 
 from langgraph.graph import END
 from langgraph.types import Command
-from langgraph.prebuilt import InjectedState
 
 from langchain_community.utilities import BingSearchAPIWrapper
 from langchain_community.tools.bing_search.tool import BingSearchResults
 from langchain_community.document_loaders import JSONLoader
 
-from langchain.agents import tool
-
 from ea4all.src.shared.configuration import (
     BaseConfiguration
 )
 
 from ea4all.src.shared.state import (
-    State
+    OverallState
     )
 
 from ea4all.src.shared.utils import (
@@ -29,6 +27,9 @@ from ea4all.src.shared.utils import (
     format_docs,
 )
 
+def make_literal_type(options):
+    return ExtLiteral[tuple(options)]
+
 def make_supervisor_node(config: RunnableConfig, members: list[str]) -> RunnableLambda:
     options = ["FINISH"] + members
     system_prompt = (
@@ -45,16 +46,20 @@ def make_supervisor_node(config: RunnableConfig, members: list[str]) -> Runnable
         api_base_url="",
     )
 
-    class Router(TypedDict):
+    NextLiteral = make_literal_type(options)
+
+    class Router():
         """Worker to route to next. If no workers needed, route to FINISH."""
 
-        next: Literal[*options]
+        def __init__(self) -> None:
+            """Initialize the Router with the next worker."""
+            self.next = make_literal_type(options)
 
-    def supervisor_node(state: State) -> Command[Literal[*members, "__end__"]]:
+    def supervisor_node(state: OverallState) -> Command:
         """An LLM-based router."""
         messages = [
             {"role": "system", "content": system_prompt},
-        ] + state["messages"]
+        ] + getattr(state,"messages"), 
         response = model.with_structured_output(Router).invoke(messages)
         goto = response["next"]
         if goto == "FINISH":
@@ -64,7 +69,7 @@ def make_supervisor_node(config: RunnableConfig, members: list[str]) -> Runnable
 
     return RunnableLambda(supervisor_node)
 
-async def websearch(state: dict[str, dict | str]) -> dict[str,dict[str,str]]:
+async def websearch(state: dict[str, list | object]) -> dict[str, object]:
     """
     Web search based on the re-phrased question.
 
@@ -84,8 +89,9 @@ async def websearch(state: dict[str, dict | str]) -> dict[str,dict[str,str]]:
         bing_search_url=bing_search_url
     )
 
-    question = getattr(state,'messages')[-1].content if getattr(state,'messages', False) else getattr(state,'question')
-
+    #question = getattr(state,'messages')[-1].content if getattr(state,'messages', False) else getattr(state,'question')
+    question = state.get('question')
+    
     ##Bing Search Results
     web_results = BingSearchResults(
         api_wrapper=search,

lgs_requirements.txt

@@ -0,0 +1,54 @@
+appnope==0.1.4
+asttokens==3.0.0
+blockbuster==1.5.25
+certifi==2025.4.26
+click==8.1.8
+comm==0.2.2
+decorator==5.2.1
+executing==2.2.0
+fsspec==2025.5.1
+greenlet==3.2.3
+hf_xet==1.1.2
+huggingface_hub==0.32.0
+ipykernel==6.29.5
+ipython==9.4.0
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+langchain==0.3.26
+langchain_core==0.3.69
+langchain_huggingface==0.3.0
+langchain_openai==0.3.28
+langgraph==0.5.3
+langgraph_api==0.2.94
+langgraph_checkpoint==2.1.1
+langgraph_prebuilt==0.5.2
+langgraph_runtime_inmem==0.5.0
+langgraph_sdk==0.1.73
+langsmith==0.4.7
+matplotlib_inline==0.1.7
+mcp==1.10.1
+openai==1.97.0
+orjson==3.10.18
+packaging==24.2
+parso==0.8.4
+pexpect==4.9.0
+platformdirs==4.3.8
+prompt_toolkit==3.0.51
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pydantic==2.11.5
+python_dotenv==1.1.0
+pyzmq==27.0.0
+requests==2.32.3
+sse_starlette==2.1.3
+stack_data==0.6.3
+starlette==0.46.2
+tokenizers==0.21.2
+tornado==6.5.1
+traitlets==5.14.3
+typing_extensions==4.13.2
+urllib3==2.4.0
+uvicorn==0.34.2
+wcwidth==0.2.13

requirements.txt

@@ -1,42 +1,162 @@
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.9
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+appnope==0.1.4
+asttokens==3.0.0
 atlassian-python-api==4.0.4
+attrs==25.3.0
+beautifulsoup4==4.13.4
+blockbuster==1.5.25
+certifi==2025.4.26
+cffi==1.17.1
+charset-normalizer==3.4.2
+click==8.1.8
+cloudpickle==3.1.1
+comm==0.2.2
+cryptography==44.0.3
+dataclasses-json==0.6.7
+debugpy==1.8.15
+decorator==5.2.1
+deprecated==1.2.18
+distro==1.9.0
+et-xmlfile==2.0.0
+executing==2.2.0
 faiss-cpu==1.11.0
-gradio==5.32.1
-gradio_client==1.10.2
-graphviz
-huggingface-hub
-jq>=1.8.0
-langchain==0.3.25
+fastapi==0.115.12
+ffmpy==0.6.0
+filelock==3.18.0
+forbiddenfruit==0.1.4
+frozenlist==1.6.2
+fsspec==2025.5.1
+gradio==5.33.0
+gradio-client==1.10.2
+graphviz==0.20.3
+greenlet==3.2.3
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.1.2
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.0
+huggingface-hub==0.32.0
+idna==3.10
+ipykernel==6.29.5
+ipython==9.4.0
+ipython-pygments-lexers==1.1.1
+jedi==0.19.2
+jinja2==3.1.6
+jiter==0.10.0
+jmespath==1.0.1
+jq==1.8.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.25.0
+jsonschema-rs==0.29.1
+jsonschema-specifications==2025.4.1
+jupyter-client==8.6.3
+jupyter-core==5.8.1
+langchain==0.3.26
 langchain-community==0.3.24
-langchain-core==0.3.61
+langchain-core==0.3.69
+langchain-huggingface==0.3.0
 langchain-mcp-adapters==0.1.4
-langchain-openai==0.3.18
+langchain-openai==0.3.28
 langchain-text-splitters==0.3.8
-langgraph==0.4.7
-langgraph-api==0.2.34
-langgraph-checkpoint==2.0.26
+langgraph==0.5.3
+langgraph-api==0.2.94
+langgraph-checkpoint==2.1.1
 langgraph-cli==0.2.10
-langgraph-prebuilt==0.2.1
-langgraph-runtime-inmem==0.2.0
-langgraph-sdk==0.1.70
-langsmith==0.3.42
-markdown
-markdownify
-mcp==1.9.2
+langgraph-prebuilt==0.5.2
+langgraph-runtime-inmem==0.5.0
+langgraph-sdk==0.1.73
+langsmith==0.4.7
+markdown==3.8
+markdown-it-py==3.0.0
+markdownify==1.1.0
+markupsafe==3.0.2
+marshmallow==3.26.1
+matplotlib-inline==0.1.7
+mcp==1.10.1
+mdurl==0.1.2
+mpmath==1.3.0
+multidict==6.4.4
+mypy-extensions==1.1.0
+nest-asyncio==1.6.0
+networkx==3.5
 numpy==2.2.6
-openai
-openpyxl
+oauthlib==3.2.2
+openai==1.97.0
+openpyxl==3.1.5
+orjson==3.10.18
+ormsgpack==1.10.0
 packaging==24.2
-pandas
-pillow
-pydantic
-pydantic-core
-pydantic-settings
-pydub
-python-dateutil
-python-dotenv
-python-multipart
-regex
-spaces
-sqlalchemy
-tiktoken
+pandas==2.2.3
+parso==0.8.4
+pexpect==4.9.0
+pillow==11.2.1
+platformdirs==4.3.8
+prompt-toolkit==3.0.51
+propcache==0.3.1
+psutil==5.9.8
+ptyprocess==0.7.0
+pure-eval==0.2.3
+pycparser==2.22
+pydantic==2.11.5
+pydantic-core==2.33.2
+pydantic-settings==2.9.1
+pydub==0.25.1
+pygments==2.19.1
+pyjwt==2.10.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
+python-multipart==0.0.20
+pytz==2025.2
+pyyaml==6.0.2
+pyzmq==27.0.0
+referencing==0.36.2
+regex==2024.11.6
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==14.0.0
+rpds-py==0.26.0
+ruff==0.11.12
+safehttpx==0.1.6
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.7
+spaces==0.36.0
+sqlalchemy==2.0.41
+sse-starlette==2.1.3
+stack-data==0.6.3
+starlette==0.46.2
+structlog==25.4.0
+sympy==1.14.0
+tenacity==9.1.2
+tiktoken==0.9.0
+tokenizers==0.21.2
+tomlkit==0.13.2
 torch==2.2.2
+tornado==6.5.1
+tqdm==4.67.1
+traitlets==5.14.3
+truststore==0.10.1
+typer==0.16.0
+typing-extensions==4.13.2
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.34.2
+watchfiles==1.0.5
+wcwidth==0.2.13
+websockets==15.0.1
+wrapt==1.17.2
+xxhash==3.5.0
+yarl==1.20.0
+zstandard==0.23.0