Code cleaning

2 utils libraries added.
The standalone and mcp server exploit on utils libraries for less updates in testing.

Author: corradodebari

src/client/mcp/rag/README.md

@@ -4,7 +4,7 @@
 **Version:** *Developer preview*
 
 ## Introduction
-This document describe how to re-use the configuration tested in the **AI Optimizer & Toolkit** an expose it as an MCP tool to a local **Claude Desktop** and how to setup as a remote MCP server. This early draft implementation utilizes the `stdio` and `sse` to interact between the agent dashboard, represented by the **Claude Desktop**, and the tool. Not always the parameters are exported at the moment, and only Ollama or OpenAI configuration are supported. 
+This document describe how to re-use the configuration tested in the **AI Optimizer & Toolkit** an expose it as an MCP tool to a local **Claude Desktop** and how to setup as a remote MCP server. This early draft implementation utilizes the `stdio` and `sse` to interact between the agent dashboard, represented by the **Claude Desktop**, and the tool. Only Ollama or OpenAI configuration are currently supported. 
 Full support will come.
 
 ## Pre-requisites.
@@ -103,17 +103,23 @@ This will impose the usage of `rag_tool` in any case.
 
 In `rag_base_optimizer_config_mcp.py`:
 
+* Update the absolute path of your `optimizer_settings.json`. Example:
+
+```python
+rag.set_optimizer_settings_path("/Users/cdebari/Documents/GitHub/ai-optimizer-mcp-export/src/client/mcp/rag/optimizer_settings.json")
+```
+
 * Substitute `Local` with `Remote client` line:
 
 ```python
-#mcp = FastMCP("research", port=8001) #Remote client
+#mcp = FastMCP("rag", port=8001) #Remote client
 mcp = FastMCP("rag") #Local
 ```
 
 * Substitute `stdio` with `sse` line of code:
 ```python
-  mcp.run(transport='stdio')
-  #mcp.run(transport='sse')
+mcp.run(transport='stdio')
+#mcp.run(transport='sse')
 ```
 
 * Start MCP server in another shell with:

src/client/mcp/rag/optimizer_utils/config.py

@@ -0,0 +1,79 @@
+from langchain_openai import ChatOpenAI
+from langchain_openai import OpenAIEmbeddings
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_ollama import OllamaEmbeddings
+from langchain_ollama import OllamaLLM
+
+from langchain_community.vectorstores.utils import DistanceStrategy
+
+from langchain_community.vectorstores import oraclevs
+from langchain_community.vectorstores.oraclevs import OracleVS
+import oracledb
+
+
+def get_llm(data):
+    llm={}
+    llm_config = data["ll_model_config"][data["user_settings"]["ll_model"]["model"]]
+    api=llm_config["api"]
+    url=llm_config["url"]
+    api_key=llm_config["api_key"]
+    model=data["user_settings"]["ll_model"]["model"]
+    print(f"CHAT_MODEL: {model} {api} {url} {api_key}")
+    if api == "ChatOllama":
+        # Initialize the LLM
+        llm = OllamaLLM(
+            model=model,
+            base_url=url
+        )
+    elif api == "OpenAI":
+        
+        llm=llm = ChatOpenAI(
+            model=model,
+            api_key=api_key
+        )
+    return llm
+
+def get_embeddings(data):
+    embeddings={}
+    model=data["user_settings"]["rag"]["model"]
+    api=data["embed_model_config"][model]["api"]
+    url=data["embed_model_config"][model]["url"]
+    api_key=data["embed_model_config"][model]["api_key"]
+    print(f"EMBEDDINGS: {model} {api} {url} {api_key}")
+    embeddings = {}
+    if  api=="OllamaEmbeddings":
+         embeddings=OllamaEmbeddings(
+            model=model,
+            base_url=url)
+    elif api == "OpenAIEmbeddings":
+         print("BEFORE create embbedding")
+         embeddings = OpenAIEmbeddings(
+            model=model,
+            api_key=api_key
+         )   
+         print("AFTER create emebdding")
+    return embeddings
+
+def get_vectorstore(data,embeddings):
+    
+    config=data["database_config"][data["user_settings"]["rag"]["database"]]
+   
+    conn23c = oracledb.connect(user=config["user"], 
+                               password=config["password"], dsn=config["dsn"])
+ 
+    print("DB Connection successful!")
+    metric=data["user_settings"]["rag"]["distance_metric"]
+    
+    dist_strategy=DistanceStrategy.COSINE
+    if metric=="COSINE":
+        dist_strategy=DistanceStrategy.COSINE
+    elif metric == "EUCLIDEAN":
+        dist_strategy=DistanceStrategy.EUCLIDEAN
+   
+    print("1")
+    a=data["user_settings"]["rag"]["vector_store"]
+    print(f"{a}")
+    print(f"BEFORE KNOWLEDGE BASE")
+    print(embeddings)
+    knowledge_base = OracleVS(conn23c, embeddings, data["user_settings"]["rag"]["vector_store"], dist_strategy)
+    return knowledge_base

src/client/mcp/rag/optimizer_utils/rag.py

@@ -0,0 +1,84 @@
+"""
+Copyright (c) 2024, 2025, Oracle and/or its affiliates.
+Licensed under the Universal Permissive License v1.0 as shown at http://oss.oracle.com/licenses/upl.
+"""
+from typing import List
+from mcp.server.fastmcp import FastMCP
+import os
+from dotenv import load_dotenv
+#from sentence_transformers import CrossEncoder
+#from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.output_parsers import StrOutputParser
+import json
+import logging
+logging.basicConfig(level=logging.DEBUG)
+
+from optimizer_utils import config
+
+_optimizer_settings_path= ""
+
+def set_optimizer_settings_path(path: str):
+    global _optimizer_settings_path
+    _optimizer_settings_path = path
+
+def rag_tool_base(question: str) -> str:
+    """
+    Use this tool to answer any question that may benefit from up-to-date or domain-specific information.
+    
+    Args:
+        question: the question for which are you looking for an answer
+        
+    Returns:
+        JSON string with answer
+    """
+    with open(_optimizer_settings_path, "r") as file:
+        data = json.load(file)
+        try: 
+        
+            embeddings = config.get_embeddings(data)
+        
+            print("Embedding successful!")
+            knowledge_base = config.get_vectorstore(data,embeddings)
+            print("DB Connection successful!")
+    
+            print("knowledge_base successful!")
+            user_question = question
+            #result_chunks=knowledge_base.similarity_search(user_question, 5)
+        
+            for d in data["prompts_config"]:
+                if d["name"]==data["user_settings"]["prompts"]["sys"]:
+             
+                    rag_prompt=d["prompt"]
+       
+            template = """DOCUMENTS: {context} \n"""+rag_prompt+"""\nQuestion: {question} """
+            #template = """Answer the question based only on the following context:{context} Question: {question} """
+            print(template)
+            prompt = PromptTemplate.from_template(template)
+            print("before retriever")
+            print(data["user_settings"]["rag"]["top_k"])
+            retriever = knowledge_base.as_retriever(search_kwargs={"k": data["user_settings"]["rag"]["top_k"]})
+            print("after retriever")
+        
+
+            # Initialize the LLM
+            llm =  config.get_llm(data)
+
+            chain = (
+                {"context": retriever, "question": RunnablePassthrough()}
+                    | prompt
+                    | llm
+                    | StrOutputParser()
+            )
+            print("pre-chain successful!")
+            answer = chain.invoke(user_question)
+
+            #print(f"Results provided for question: {question}")
+            #print(f"{answer}")
+        except Exception as e:
+            print(e)
+            print("Connection failed!")
+            answer=""
+
+    return f"{answer}"