#
tokens: 49933/50000 57/501 files (page 4/16)
lines: off (toggle) GitHub
raw markdown copy
This is page 4 of 16. Use http://codebase.md/fujitsu-ai/mcp-server-for-mas-developments?lines=false&page={x} to view the full context.

# Directory Structure

```
├── .gitattributes
├── .gitignore
├── agents
│   ├── __init__.py
│   ├── AgentInterface
│   │   ├── __init__.py
│   │   ├── Python
│   │   │   ├── __init__.py
│   │   │   ├── agent.py
│   │   │   ├── color.py
│   │   │   ├── config.py
│   │   │   ├── language.py
│   │   │   ├── local_file_handler.py
│   │   │   └── network.py
│   │   └── requirements.txt
│   ├── AgentMonitoring
│   │   ├── ChatBot-Agent Dashboard Example - Grafana.json
│   │   ├── images
│   │   │   ├── Grafana.png
│   │   │   └── Prometheus.png
│   │   ├── IoT-Agent Dashboard Example - Grafana.json
│   │   ├── OpenAI compatible API - Agent Dashboard Example - Grafana.json
│   │   ├── prometheus Example.yml
│   │   └── README.md
│   ├── ChatBotAgent
│   │   ├── __init__.py
│   │   ├── config.json.example
│   │   ├── html
│   │   │   ├── favicon.ico
│   │   │   ├── index_de.html
│   │   │   ├── index.html
│   │   │   ├── Logo_light.svg
│   │   │   ├── start_http_server.ps1
│   │   │   └── start_http_server.sh
│   │   ├── Python
│   │   │   ├── __init__.py
│   │   │   └── chatbot_agent.py
│   │   ├── README.md
│   │   └── requirements.txt
│   ├── IoTAgent
│   │   ├── config_example.json
│   │   ├── Python
│   │   │   ├── iot_mqtt_agent.py
│   │   │   └── language.py
│   │   ├── README.md
│   │   └── requirements.txt
│   ├── MCP-Client
│   │   ├── __init__.py
│   │   ├── .env.example
│   │   ├── Python
│   │   │   ├── __init__.py
│   │   │   ├── chat_handler.py
│   │   │   ├── config.py
│   │   │   ├── environment.py
│   │   │   ├── llm_client.py
│   │   │   ├── mcp_client_sse.py
│   │   │   ├── mcp_client.py
│   │   │   ├── messages
│   │   │   │   ├── __init__.py
│   │   │   │   ├── message_types
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── incrementing_id_message.py
│   │   │   │   │   ├── initialize_message.py
│   │   │   │   │   ├── json_rpc_message.py
│   │   │   │   │   ├── ping_message.py
│   │   │   │   │   ├── prompts_messages.py
│   │   │   │   │   ├── prompts_models.py
│   │   │   │   │   ├── resources_messages.py
│   │   │   │   │   └── tools_messages.py
│   │   │   │   ├── send_call_tool.py
│   │   │   │   ├── send_initialize_message.py
│   │   │   │   ├── send_message.py
│   │   │   │   ├── send_ping.py
│   │   │   │   ├── send_prompts.py
│   │   │   │   ├── send_resources.py
│   │   │   │   └── send_tools_list.py
│   │   │   ├── system_prompt_generator.py
│   │   │   ├── tools_handler.py
│   │   │   └── transport
│   │   │       ├── __init__.py
│   │   │       └── stdio
│   │   │           ├── __init__.py
│   │   │           ├── stdio_client.py
│   │   │           ├── stdio_server_parameters.py
│   │   │           └── stdio_server_shutdown.py
│   │   ├── README.md
│   │   ├── requirements.txt
│   │   └── server_config.json
│   ├── OpenAI_Compatible_API_Agent
│   │   ├── __init__.py
│   │   ├── docker-compose.yml
│   │   ├── Dockerfile
│   │   ├── pgpt_openai_api_mcp.json.example
│   │   ├── pgpt_openai_api_proxy.json.example
│   │   ├── Python
│   │   │   ├── __init__.py
│   │   │   ├── client_tests
│   │   │   │   ├── __init__.py
│   │   │   │   ├── openai_test_client_structured.py
│   │   │   │   ├── openai_test_client_tools.py
│   │   │   │   ├── openai_test_client.py
│   │   │   │   ├── vllm_client_multimodal.py
│   │   │   │   ├── vllm_client.py
│   │   │   │   ├── vllm_structured.py
│   │   │   │   └── vllm_structured2.py
│   │   │   ├── generate_api_key.py
│   │   │   ├── open_ai_helper.py
│   │   │   ├── openai_compatible_api.py
│   │   │   ├── openai_mcp_api.py
│   │   │   ├── pgpt_api.py
│   │   │   ├── privategpt_api.py
│   │   │   └── vllmproxy.py
│   │   ├── README.md
│   │   └── requirements.txt
│   └── SourceManagerAgent
│       ├── __init__.py
│       ├── config.json.example
│       └── Python
│           ├── __init__.py
│           ├── file_tools
│           │   └── loader_factory.py
│           ├── file_upload_agent.py
│           └── local_db.py
├── clients
│   ├── __init__.py
│   ├── C# .Net
│   │   ├── 1.0 mcp_login
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_login.deps.json
│   │   │   │           ├── mcp_login.dll
│   │   │   │           ├── mcp_login.exe
│   │   │   │           ├── mcp_login.pdb
│   │   │   │           ├── mcp_login.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_login.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_login.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_login.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_login.assets.cache
│   │   │   │   │       ├── mcp_login.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_login.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_login.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_login.csproj.Up2Date
│   │   │   │   │       ├── mcp_login.dll
│   │   │   │   │       ├── mcp_login.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_login.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_login.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_login.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_login.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_login.dll
│   │   │   │   ├── mcp_login.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_login.csproj.nuget.g.props
│   │   │   │   ├── mcp_login.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 1.1 mcp_logout
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_logout.deps.json
│   │   │   │           ├── mcp_logout.dll
│   │   │   │           ├── mcp_logout.exe
│   │   │   │           ├── mcp_logout.pdb
│   │   │   │           ├── mcp_logout.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_logout.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_logout.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_logout.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_logout.assets.cache
│   │   │   │   │       ├── mcp_logout.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_logout.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_logout.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_logout.csproj.Up2Date
│   │   │   │   │       ├── mcp_logout.dll
│   │   │   │   │       ├── mcp_logout.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_logout.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_logout.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_logout.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_logout.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_logout.dll
│   │   │   │   ├── mcp_logout.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_logout.csproj.nuget.g.props
│   │   │   │   ├── mcp_logout.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 2.0 mcp_chat
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_chat.deps.json
│   │   │   │           ├── mcp_chat.dll
│   │   │   │           ├── mcp_chat.exe
│   │   │   │           ├── mcp_chat.pdb
│   │   │   │           ├── mcp_chat.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_chat.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_chat.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_chat.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_chat.assets.cache
│   │   │   │   │       ├── mcp_chat.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_chat.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_chat.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_chat.csproj.Up2Date
│   │   │   │   │       ├── mcp_chat.dll
│   │   │   │   │       ├── mcp_chat.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_chat.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_chat.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_chat.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_chat.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_chat.dll
│   │   │   │   ├── mcp_chat.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_chat.csproj.nuget.g.props
│   │   │   │   ├── mcp_chat.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 2.1 mcp_continue_chat
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_continue_chat.deps.json
│   │   │   │           ├── mcp_continue_chat.dll
│   │   │   │           ├── mcp_continue_chat.exe
│   │   │   │           ├── mcp_continue_chat.pdb
│   │   │   │           ├── mcp_continue_chat.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_continue_chat.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_cont.EF178231.Up2Date
│   │   │   │   │       ├── mcp_continue_chat.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_continue_chat.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_continue_chat.assets.cache
│   │   │   │   │       ├── mcp_continue_chat.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_continue_chat.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_continue_chat.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_continue_chat.dll
│   │   │   │   │       ├── mcp_continue_chat.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_continue_chat.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_continue_chat.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_continue_chat.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_continue_chat.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_continue_chat.dll
│   │   │   │   ├── mcp_continue_chat.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_continue_chat.csproj.nuget.g.props
│   │   │   │   ├── mcp_continue_chat.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 2.2 mcp_get_chat_info
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_get_chat_info.deps.json
│   │   │   │           ├── mcp_get_chat_info.dll
│   │   │   │           ├── mcp_get_chat_info.exe
│   │   │   │           ├── mcp_get_chat_info.pdb
│   │   │   │           ├── mcp_get_chat_info.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── Dokumente - Verknüpfung.lnk
│   │   │   ├── mcp_get_chat_info.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_get_.DFF47B4E.Up2Date
│   │   │   │   │       ├── mcp_get_chat_info.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_get_chat_info.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_get_chat_info.assets.cache
│   │   │   │   │       ├── mcp_get_chat_info.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_get_chat_info.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_get_chat_info.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_get_chat_info.dll
│   │   │   │   │       ├── mcp_get_chat_info.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_get_chat_info.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_get_chat_info.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_get_chat_info.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_get_chat_info.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_get_chat_info.dll
│   │   │   │   ├── mcp_get_chat_info.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_get_chat_info.csproj.nuget.g.props
│   │   │   │   ├── mcp_get_chat_info.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 3.0 mcp_create_source
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_create_source.deps.json
│   │   │   │           ├── mcp_create_source.dll
│   │   │   │           ├── mcp_create_source.exe
│   │   │   │           ├── mcp_create_source.pdb
│   │   │   │           ├── mcp_create_source.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_create_source.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_crea.CB4ED912.Up2Date
│   │   │   │   │       ├── mcp_create_source.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_create_source.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_create_source.assets.cache
│   │   │   │   │       ├── mcp_create_source.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_create_source.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_create_source.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_create_source.dll
│   │   │   │   │       ├── mcp_create_source.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_create_source.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_create_source.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_create_source.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_create_source.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_create_source.dll
│   │   │   │   ├── mcp_create_source.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_create_source.csproj.nuget.g.props
│   │   │   │   ├── mcp_create_source.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 3.1 mcp_get_source
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_get_source.deps.json
│   │   │   │           ├── mcp_get_source.dll
│   │   │   │           ├── mcp_get_source.exe
│   │   │   │           ├── mcp_get_source.pdb
│   │   │   │           ├── mcp_get_source.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_get_source.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_get_.4E61956F.Up2Date
│   │   │   │   │       ├── mcp_get_source.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_get_source.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_get_source.assets.cache
│   │   │   │   │       ├── mcp_get_source.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_get_source.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_get_source.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_get_source.dll
│   │   │   │   │       ├── mcp_get_source.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_get_source.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_get_source.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_get_source.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_get_source.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_get_source.dll
│   │   │   │   ├── mcp_get_source.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_get_source.csproj.nuget.g.props
│   │   │   │   ├── mcp_get_source.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 3.2 mcp_list_sources
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_list_sources.deps.json
│   │   │   │           ├── mcp_list_sources.dll
│   │   │   │           ├── mcp_list_sources.exe
│   │   │   │           ├── mcp_list_sources.pdb
│   │   │   │           ├── mcp_list_sources.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_list_sources.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_list_sources.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_list_sources.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_list_sources.assets.cache
│   │   │   │   │       ├── mcp_list_sources.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_list_sources.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_list_sources.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_list_sources.dll
│   │   │   │   │       ├── mcp_list_sources.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_list_sources.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_list_sources.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_list_sources.pdb
│   │   │   │   │       ├── mcp_list.A720E197.Up2Date
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_list_sources.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_list_sources.dll
│   │   │   │   ├── mcp_list_sources.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_list_sources.csproj.nuget.g.props
│   │   │   │   ├── mcp_list_sources.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 3.3 mcp_edit_source
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_edit_source.deps.json
│   │   │   │           ├── mcp_edit_source.dll
│   │   │   │           ├── mcp_edit_source.exe
│   │   │   │           ├── mcp_edit_source.pdb
│   │   │   │           ├── mcp_edit_source.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_edit_source.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_edit_source.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_edit_source.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_edit_source.assets.cache
│   │   │   │   │       ├── mcp_edit_source.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_edit_source.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_edit_source.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_edit_source.dll
│   │   │   │   │       ├── mcp_edit_source.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_edit_source.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_edit_source.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_edit_source.pdb
│   │   │   │   │       ├── mcp_edit.7303BE3B.Up2Date
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_edit_source.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_edit_source.dll
│   │   │   │   ├── mcp_edit_source.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_edit_source.csproj.nuget.g.props
│   │   │   │   ├── mcp_edit_source.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 3.4 mcp_delete_source
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_delete_source.deps.json
│   │   │   │           ├── mcp_delete_source.dll
│   │   │   │           ├── mcp_delete_source.exe
│   │   │   │           ├── mcp_delete_source.pdb
│   │   │   │           ├── mcp_delete_source.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_delete_source.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_dele.67DD13F9.Up2Date
│   │   │   │   │       ├── mcp_delete_source.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_delete_source.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_delete_source.assets.cache
│   │   │   │   │       ├── mcp_delete_source.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_delete_source.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_delete_source.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_delete_source.dll
│   │   │   │   │       ├── mcp_delete_source.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_delete_source.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_delete_source.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_delete_source.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_delete_source.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_delete_source.dll
│   │   │   │   ├── mcp_delete_source.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_delete_source.csproj.nuget.g.props
│   │   │   │   ├── mcp_delete_source.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 4.0 mcp_list_groups
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_list_groups.deps.json
│   │   │   │           ├── mcp_list_groups.dll
│   │   │   │           ├── mcp_list_groups.exe
│   │   │   │           ├── mcp_list_groups.pdb
│   │   │   │           ├── mcp_list_groups.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_list_groups.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_list_groups.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_list_groups.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_list_groups.assets.cache
│   │   │   │   │       ├── mcp_list_groups.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_list_groups.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_list_groups.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_list_groups.dll
│   │   │   │   │       ├── mcp_list_groups.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_list_groups.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_list_groups.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_list_groups.pdb
│   │   │   │   │       ├── mcp_list.EBD5E0D2.Up2Date
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_list_groups.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_list_groups.dll
│   │   │   │   ├── mcp_list_groups.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_list_groups.csproj.nuget.g.props
│   │   │   │   ├── mcp_list_groups.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 4.1 mcp_store_group
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_store_group.deps.json
│   │   │   │           ├── mcp_store_group.dll
│   │   │   │           ├── mcp_store_group.exe
│   │   │   │           ├── mcp_store_group.pdb
│   │   │   │           ├── mcp_store_group.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_store_group.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_stor.AFB4AA35.Up2Date
│   │   │   │   │       ├── mcp_store_group.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_store_group.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_store_group.assets.cache
│   │   │   │   │       ├── mcp_store_group.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_store_group.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_store_group.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_store_group.dll
│   │   │   │   │       ├── mcp_store_group.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_store_group.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_store_group.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_store_group.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_store_group.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_store_group.dll
│   │   │   │   ├── mcp_store_group.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_store_group.csproj.nuget.g.props
│   │   │   │   ├── mcp_store_group.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 4.2 mcp_delete_group
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_delete_group.deps.json
│   │   │   │           ├── mcp_delete_group.dll
│   │   │   │           ├── mcp_delete_group.exe
│   │   │   │           ├── mcp_delete_group.pdb
│   │   │   │           ├── mcp_delete_group.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_delete_group.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_dele.FE1C6298.Up2Date
│   │   │   │   │       ├── mcp_delete_group.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_delete_group.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_delete_group.assets.cache
│   │   │   │   │       ├── mcp_delete_group.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_delete_group.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_delete_group.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_delete_group.dll
│   │   │   │   │       ├── mcp_delete_group.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_delete_group.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_delete_group.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_delete_group.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_delete_group.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_delete_group.dll
│   │   │   │   ├── mcp_delete_group.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_delete_group.csproj.nuget.g.props
│   │   │   │   ├── mcp_delete_group.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 5.0 mcp_store_user
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_store_user.deps.json
│   │   │   │           ├── mcp_store_user.dll
│   │   │   │           ├── mcp_store_user.exe
│   │   │   │           ├── mcp_store_user.pdb
│   │   │   │           ├── mcp_store_user.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_store_user.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_stor.6C0F0C8A.Up2Date
│   │   │   │   │       ├── mcp_store_user.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_store_user.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_store_user.assets.cache
│   │   │   │   │       ├── mcp_store_user.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_store_user.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_store_user.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_store_user.dll
│   │   │   │   │       ├── mcp_store_user.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_store_user.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_store_user.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_store_user.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_store_user.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_store_user.dll
│   │   │   │   ├── mcp_store_user.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_store_user.csproj.nuget.g.props
│   │   │   │   ├── mcp_store_user.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 5.1 mcp_edit_user
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_edit_user.deps.json
│   │   │   │           ├── mcp_edit_user.dll
│   │   │   │           ├── mcp_edit_user.exe
│   │   │   │           ├── mcp_edit_user.pdb
│   │   │   │           ├── mcp_edit_user.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_edit_user.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_edit_user.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_edit_user.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_edit_user.assets.cache
│   │   │   │   │       ├── mcp_edit_user.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_edit_user.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_edit_user.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_edit_user.dll
│   │   │   │   │       ├── mcp_edit_user.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_edit_user.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_edit_user.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_edit_user.pdb
│   │   │   │   │       ├── mcp_edit.94A30270.Up2Date
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_edit_user.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_edit_user.dll
│   │   │   │   ├── mcp_edit_user.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_edit_user.csproj.nuget.g.props
│   │   │   │   ├── mcp_edit_user.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── 5.2 mcp_delete_user
│   │   │   ├── bin
│   │   │   │   └── Debug
│   │   │   │       └── net9.0
│   │   │   │           ├── mcp_delete_user.deps.json
│   │   │   │           ├── mcp_delete_user.dll
│   │   │   │           ├── mcp_delete_user.exe
│   │   │   │           ├── mcp_delete_user.pdb
│   │   │   │           ├── mcp_delete_user.runtimeconfig.json
│   │   │   │           └── Newtonsoft.Json.dll
│   │   │   ├── mcp_delete_user.csproj
│   │   │   ├── obj
│   │   │   │   ├── Debug
│   │   │   │   │   └── net9.0
│   │   │   │   │       ├── .NETCoreApp,Version=v9.0.AssemblyAttributes.cs
│   │   │   │   │       ├── apphost.exe
│   │   │   │   │       ├── mcp_dele.CEB7E33D.Up2Date
│   │   │   │   │       ├── mcp_delete_user.AssemblyInfo.cs
│   │   │   │   │       ├── mcp_delete_user.AssemblyInfoInputs.cache
│   │   │   │   │       ├── mcp_delete_user.assets.cache
│   │   │   │   │       ├── mcp_delete_user.csproj.AssemblyReference.cache
│   │   │   │   │       ├── mcp_delete_user.csproj.CoreCompileInputs.cache
│   │   │   │   │       ├── mcp_delete_user.csproj.FileListAbsolute.txt
│   │   │   │   │       ├── mcp_delete_user.dll
│   │   │   │   │       ├── mcp_delete_user.GeneratedMSBuildEditorConfig.editorconfig
│   │   │   │   │       ├── mcp_delete_user.genruntimeconfig.cache
│   │   │   │   │       ├── mcp_delete_user.GlobalUsings.g.cs
│   │   │   │   │       ├── mcp_delete_user.pdb
│   │   │   │   │       ├── ref
│   │   │   │   │       │   └── mcp_delete_user.dll
│   │   │   │   │       └── refint
│   │   │   │   │           └── mcp_delete_user.dll
│   │   │   │   ├── mcp_delete_user.csproj.nuget.dgspec.json
│   │   │   │   ├── mcp_delete_user.csproj.nuget.g.props
│   │   │   │   ├── mcp_delete_user.csproj.nuget.g.targets
│   │   │   │   ├── project.assets.json
│   │   │   │   └── project.nuget.cache
│   │   │   └── Program.cs
│   │   ├── Code Archiv
│   │   │   ├── mcp_chat.cs
│   │   │   ├── mcp_continue_chat.cs
│   │   │   ├── mcp_create_source.cs
│   │   │   ├── mcp_delete_group.cs
│   │   │   ├── mcp_delete_source.cs
│   │   │   ├── mcp_delete_user.cs
│   │   │   ├── mcp_edit_source.cs
│   │   │   ├── mcp_edit_user.cs
│   │   │   ├── mcp_get_chat_info.cs
│   │   │   ├── mcp_get_source.cs
│   │   │   ├── mcp_list_groups.cs
│   │   │   ├── mcp_list_sources.cs
│   │   │   ├── mcp_login.cs
│   │   │   ├── mcp_logout.cs
│   │   │   ├── mcp_store_group.cs
│   │   │   └── mcp_store_user.cs
│   │   └── README.md
│   ├── C++
│   │   ├── .vscode
│   │   │   └── launch.json
│   │   ├── 1.0 mcp_login
│   │   │   ├── MCPLoginClient.cpp
│   │   │   └── Non-TLS version
│   │   │       ├── MCPLoginClient.cpp
│   │   │       └── MCPLoginClient.exe
│   │   ├── 1.1 mcp_logout
│   │   │   ├── MCPLogoutClient.cpp
│   │   │   └── MCPLogoutClient.exe
│   │   ├── 2.0 mcp_chat
│   │   │   ├── MCPChatClient.cpp
│   │   │   └── MCPChatClient.exe
│   │   ├── 2.1 mcp_continue_chat
│   │   │   ├── MCPChatContinuationClient.cpp
│   │   │   └── MCPChatContinuationClient.exe
│   │   ├── 2.2 mcp_get_chat_info
│   │   │   ├── MCPGetChatInfoClient.cpp
│   │   │   └── MCPGetChatInfoClient.exe
│   │   ├── 3.0 mcp_create_source
│   │   │   ├── MCPCreateSourceClient.cpp
│   │   │   └── MCPCreateSourceClient.exe
│   │   ├── 3.1 mcp_get_source
│   │   │   ├── MCPGetSourceClient.cpp
│   │   │   └── MCPGetSourceClient.exe
│   │   ├── 3.2 mcp_list_sources
│   │   │   ├── MCPListSourcesClient.cpp
│   │   │   └── MCPListSourcesClient.exe
│   │   ├── 3.3 mcp_edit_source
│   │   │   ├── MCPEditSourceClient.cpp
│   │   │   └── MCPEditSourceClient.exe
│   │   ├── 3.4 mcp_delete_source
│   │   │   ├── MCPDeleteSourceClient.cpp
│   │   │   └── MCPDeleteSourceClient.exe
│   │   ├── 4.0 mcp_list_groups
│   │   │   ├── MCPListGroupsClient.cpp
│   │   │   └── MCPListGroupsClient.exe
│   │   ├── 4.1 mcp_store_group
│   │   │   ├── MCPStoreGroupClient.cpp
│   │   │   └── MCPStoreGroupClient.exe
│   │   ├── 4.2 mcp_delete_group
│   │   │   ├── MPCDeleteGroupClient.cpp
│   │   │   └── MPCDeleteGroupClient.exe
│   │   ├── 5.0 mcp_store_user
│   │   │   ├── MCPStoreUserClient.cpp
│   │   │   └── MCPStoreUserClient.exe
│   │   ├── 5.1 mcp_edit_user
│   │   │   ├── MCPEditUserClient.cpp
│   │   │   └── MCPEditUserClient.exe
│   │   ├── 5.2 mcp_delete_user
│   │   │   ├── MCPDeleteUserClient.cpp
│   │   │   └── MCPDeleteUserClient.exe
│   │   ├── 9.0 mcp_keygen
│   │   │   ├── MCPKeygenClient.cpp
│   │   │   └── MCPKeygenClient.exe
│   │   └── README.md
│   ├── Go
│   │   ├── 1.0 mcp_login
│   │   │   ├── go.mod
│   │   │   ├── MCPLoginClient.exe
│   │   │   └── MCPLoginClient.go
│   │   ├── 1.1 mcp_logout
│   │   │   ├── MCPLogoutClient.exe
│   │   │   └── MCPLogoutClient.go
│   │   ├── 2.0 mcp_chat
│   │   │   ├── MCPChatClient.exe
│   │   │   └── MCPChatClient.go
│   │   ├── 2.1 mcp_continue_chat
│   │   │   ├── MCPChatContinuationClient.exe
│   │   │   └── MCPChatContinuationClient.go
│   │   ├── 2.2 mcp_get_chat_info
│   │   │   ├── MCPGetChatInfoClient.exe
│   │   │   └── MCPGetChatInfoClient.go
│   │   ├── 3.0 mcp_create_source
│   │   │   ├── MCPCreateSourceClient.exe
│   │   │   └── MCPCreateSourceClient.go
│   │   ├── 3.1 mcp_get_source
│   │   │   ├── MCPGetSourceClient.exe
│   │   │   └── MCPGetSourceClient.go
│   │   ├── 3.2 mcp_list_sources
│   │   │   ├── MCPListSourcesClient.exe
│   │   │   └── MCPListSourcesClient.go
│   │   ├── 3.3 mcp_edit_source
│   │   │   ├── MCPEditSourceClient.exe
│   │   │   └── MCPEditSourceClient.go
│   │   ├── 3.4 mcp_delete_source
│   │   │   ├── MCPDeleteSourceClient.exe
│   │   │   └── MCPDeleteSourceClient.go
│   │   ├── 4.0 mcp_list_groups
│   │   │   ├── MCPListGroupsClient.exe
│   │   │   └── MCPListGroupsClient.go
│   │   ├── 4.1 mcp_store_group
│   │   │   ├── MCPStoreGroupClient.exe
│   │   │   └── MCPStoreGroupClient.go
│   │   ├── 4.2 mcp_delete_group
│   │   │   ├── MCPDeleteGroupClient.exe
│   │   │   └── MCPDeleteGroupClient.go
│   │   ├── 5.0 mcp_store_user
│   │   │   ├── MCPStoreUserClient.exe
│   │   │   └── MCPStoreUserClient.go
│   │   ├── 5.1 mcp_edit_user
│   │   │   ├── MCPEditUserClient.exe
│   │   │   └── MCPEditUserClient.go
│   │   ├── 5.2 mcp_delete_user
│   │   │   ├── MCPDeleteUserClient.exe
│   │   │   └── MCPDeleteUserClient.go
│   │   ├── 9.0 mcp_keygen
│   │   │   ├── MCPKeygenClient.exe
│   │   │   └── MCPKeygenClient.go
│   │   └── README.md
│   ├── Gradio
│   │   ├── Api.py
│   │   ├── config.json.example
│   │   ├── config.py
│   │   ├── favicon.ico
│   │   ├── file_tools
│   │   │   └── loader_factory.py
│   │   ├── language.py
│   │   ├── logos
│   │   │   ├── fsas.png
│   │   │   └── Logo_dark.svg
│   │   ├── main.py
│   │   ├── mcp_client.py
│   │   ├── mcp_servers
│   │   │   ├── arxiv
│   │   │   │   ├── arxiv-stdio.js
│   │   │   │   ├── package.json
│   │   │   │   ├── README.md
│   │   │   │   ├── requirements.txt
│   │   │   │   └── server_config.example.json
│   │   │   ├── demo-mcp-server
│   │   │   │   ├── demo-tools-sse.js
│   │   │   │   ├── demo-tools-stdio.js
│   │   │   │   └── tools
│   │   │   │       ├── assets.js
│   │   │   │       ├── calculator.js
│   │   │   │       └── weather.js
│   │   │   ├── filesystem
│   │   │   │   ├── Dockerfile
│   │   │   │   ├── index.ts
│   │   │   │   ├── package.json
│   │   │   │   ├── README.md
│   │   │   │   ├── test
│   │   │   │   │   └── new.txt
│   │   │   │   └── tsconfig.json
│   │   │   ├── moondream
│   │   │   │   └── server.py
│   │   │   ├── pgpt
│   │   │   │   ├── __init__.py
│   │   │   │   ├── Api.py
│   │   │   │   ├── config.json.example
│   │   │   │   ├── config.py
│   │   │   │   ├── language.py
│   │   │   │   ├── pyproject.toml
│   │   │   │   ├── README.md
│   │   │   │   └── server.py
│   │   │   ├── replicate_flux
│   │   │   │   └── server.py
│   │   │   └── sqlite
│   │   │       ├── .python-version
│   │   │       ├── Dockerfile
│   │   │       ├── pyproject.toml
│   │   │       ├── README.md
│   │   │       └── src
│   │   │           └── mcp_server_sqlite
│   │   │               ├── __init__.py
│   │   │               └── server.py
│   │   ├── messages
│   │   │   ├── __init__.py
│   │   │   ├── message_types
│   │   │   │   ├── __init__.py
│   │   │   │   ├── incrementing_id_message.py
│   │   │   │   ├── initialize_message.py
│   │   │   │   ├── json_rpc_message.py
│   │   │   │   ├── ping_message.py
│   │   │   │   ├── prompts_messages.py
│   │   │   │   ├── prompts_models.py
│   │   │   │   ├── resources_messages.py
│   │   │   │   └── tools_messages.py
│   │   │   ├── send_call_tool.py
│   │   │   ├── send_initialize_message.py
│   │   │   ├── send_message.py
│   │   │   ├── send_ping.py
│   │   │   ├── send_prompts.py
│   │   │   ├── send_resources.py
│   │   │   └── send_tools_list.py
│   │   ├── README.md
│   │   ├── requirements.txt
│   │   ├── server_config.json
│   │   ├── SourceManagement.py
│   │   ├── transport
│   │   │   ├── __init__.py
│   │   │   └── stdio
│   │   │       ├── __init__.py
│   │   │       ├── stdio_client.py
│   │   │       ├── stdio_server_parameters.py
│   │   │       └── stdio_server_shutdown.py
│   │   ├── tsconfig.json
│   │   └── UserManagement.py
│   ├── Java
│   │   ├── 1.0 mcp_login
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPLoginClient.class
│   │   │   └── MCPLoginClient.java
│   │   ├── 1.1 mcp_logout
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPLogoutClient.class
│   │   │   └── MCPLogoutClient.java
│   │   ├── 2.0 mcp_chat
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPChatClient.class
│   │   │   └── MCPChatClient.java
│   │   ├── 2.1 mcp_continue_chat
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPContinueChatClient.class
│   │   │   └── MCPContinueChatClient.java
│   │   ├── 2.2 mcp_get_chat_info
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPGetChatInfoClient.class
│   │   │   └── MCPGetChatInfoClient.java
│   │   ├── 3.0 mcp_create_source
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPCreateSourceClient.class
│   │   │   └── MCPCreateSourceClient.java
│   │   ├── 3.1 mcp_get_source
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPGetSourceClient.class
│   │   │   └── MCPGetSourceClient.java
│   │   ├── 3.2 mcp_list_sources
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPListSourcesClient.class
│   │   │   └── MCPListSourcesClient.java
│   │   ├── 3.3 mcp_edit_source
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPEditSourceClient.class
│   │   │   └── MCPEditSourceClient.java
│   │   ├── 3.4 mcp_delete_source
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPDeleteSourceClient.class
│   │   │   └── MCPDeleteSourceClient.java
│   │   ├── 4.0 mcp_list_groups
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPListGroupsClient.class
│   │   │   └── MCPListGroupsClient.java
│   │   ├── 4.1 mcp_store_group
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPStoreGroupClient.class
│   │   │   └── MCPStoreGroupClient.java
│   │   ├── 4.2 mcp_delete_group
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPDeleteGroupClient.class
│   │   │   └── MCPDeleteGroupClient.java
│   │   ├── 5.0 mcp_store_user
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPStoreUserClient.class
│   │   │   └── MCPStoreUserClient.java
│   │   ├── 5.1 mcp_edit_user
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPEditUserClient.class
│   │   │   └── MCPEditUserClient.java
│   │   ├── 5.2 mcp_delete_user
│   │   │   ├── json-20241224.jar
│   │   │   ├── MCPDeleteUserClient.class
│   │   │   └── MCPDeleteUserClient.java
│   │   └── README.md
│   ├── JavaScript
│   │   ├── 1.0 mcp_login
│   │   │   └── MCPLoginClient.js
│   │   ├── 1.1 mcp_logout
│   │   │   └── MCPLogoutClient.js
│   │   ├── 2.0 mcp_chat
│   │   │   └── MCPChatClient.js
│   │   ├── 2.1 mcp_continue_chat
│   │   │   └── MCPContinueChatClient.js
│   │   ├── 2.2 mcp_get_chat_info
│   │   │   └── MCPGetChatInfoClient.js
│   │   ├── 3.0 mcp_create_source
│   │   │   └── MCPCreateSourceClient.js
│   │   ├── 3.1 mcp_get_source
│   │   │   └── MCPGetSourceClient.js
│   │   ├── 3.2 mcp_list_sources
│   │   │   └── MCPListSourcesClient.js
│   │   ├── 3.3 mcp_edit_source
│   │   │   └── MCPEditSourceClient.js
│   │   ├── 3.4 mcp_delete_source
│   │   │   └── MCPDeleteSourceClient.js
│   │   ├── 4.0 mcp_list_groups
│   │   │   └── MCPListGroupsClient.js
│   │   ├── 4.1 mcp_store_group
│   │   │   └── MCPStoreGroupClient.js
│   │   ├── 4.2 mcp_delete_group
│   │   │   └── MCPDeleteGroupClient.js
│   │   ├── 5.0 mcp_store_user
│   │   │   └── MCPStoreUserClient.js
│   │   ├── 5.1 mcp_edit_user
│   │   │   └── MCPEditUserClient.js
│   │   ├── 5.2 mcp_delete_user
│   │   │   └── MCPDeleteUserClient.js
│   │   ├── 9.0 mcp_keygen
│   │   │   └── MCPKeygenClient.js
│   │   └── README.md
│   ├── PHP
│   │   ├── 1.0 mcp_login
│   │   │   └── MCPLoginClient.php
│   │   ├── 1.1 mcp_logout
│   │   │   └── MCPLogoutClient.php
│   │   ├── 2.0 mcp_chat
│   │   │   └── MCPChatClient.php
│   │   ├── 2.1 mcp_continue_chat
│   │   │   └── MCPContinueChatClient.php
│   │   ├── 2.2 mcp_get_chat_info
│   │   │   └── MCPGetChatInfoClient.php
│   │   ├── 3.0 mcp_create_source
│   │   │   └── MCPCreateSourceClient.php
│   │   ├── 3.1 mcp_get_source
│   │   │   └── MCPGetSourceClient.php
│   │   ├── 3.2 mcp_list_sources
│   │   │   └── MCPListSourcesClient.php
│   │   ├── 3.3 mcp_edit_source
│   │   │   └── MCPEditSourceClient.php
│   │   ├── 3.4 mcp_delete_source
│   │   │   └── MCPDeleteSourceClient.php
│   │   ├── 4.0 mcp_list_groups
│   │   │   └── MCPListGroupsClient.php
│   │   ├── 4.1 mcp_store_group
│   │   │   └── MCPStoreGroupClient.php
│   │   ├── 4.2 mcp_delete_group
│   │   │   └── MCPDeleteGroupClient.php
│   │   ├── 5.0 mcp_store_user
│   │   │   └── MCPStoreUserClient.php
│   │   ├── 5.1 mcp_edit_user
│   │   │   └── MCPEditUserClient.php
│   │   ├── 5.2 mcp_delete_user
│   │   │   └── MCPDeleteUserClient.php
│   │   ├── 9.0 mcp_keygen
│   │   │   └── MCPKeygenClient.php
│   │   └── README.md
│   └── Python
│       ├── __init__.py
│       ├── 1.0 mcp_login
│       │   └── MCPLoginClient.py
│       ├── 1.1 mcp_logout
│       │   └── MCPLogoutClient.py
│       ├── 2.0 mcp_chat
│       │   └── MCPChatClient.py
│       ├── 2.1 mcp_continue_chat
│       │   └── MCPContinueChatClient.py
│       ├── 2.2 mcp_get_chat_info
│       │   └── MCPGetChatInfoClient.py
│       ├── 2.3 mcp_delete_all_chats
│       │   └── MCPDeleteAllChatsClient.py
│       ├── 2.4 mcp_delete_chat
│       │   └── MCPDeleteChatClient.py
│       ├── 3.0 mcp_create_source
│       │   └── MCPCreateSourceClient.py
│       ├── 3.1 mcp_get_source
│       │   └── MCPGetSourceClient.py
│       ├── 3.2 mcp_list_sources
│       │   └── MCPListSourcesClient.py
│       ├── 3.3 mcp_edit_source
│       │   └── MCPEditSourceClient.py
│       ├── 3.4 mcp_delete_source
│       │   └── MCPDeleteSourceClient.py
│       ├── 4.0 mcp_list_groups
│       │   └── MCPListGroupsClient.py
│       ├── 4.1 mcp_store_group
│       │   └── MCPStoreGroupClient.py
│       ├── 4.2 mcp_delete_group
│       │   └── MCPDeleteGroupClient.py
│       ├── 5.0 mcp_store_user
│       │   └── MCPStoreUserClient.py
│       ├── 5.1 mcp_edit_user
│       │   └── MCPEditUserClient.py
│       ├── 5.2 mcp_delete_user
│       │   └── MCPDeleteUserClient.py
│       ├── 9.0 mcp_keygen
│       │   └── MCPKeygenClient.py
│       ├── Gradio
│       │   ├── __init__.py
│       │   └── server_config.json
│       └── README.md
├── examples
│   ├── create_users_from_csv
│   │   ├── config.json.example
│   │   ├── config.py
│   │   ├── create_users_from_csv.py
│   │   └── language.py
│   ├── dynamic_sources
│   │   └── rss_reader
│   │       ├── Api.py
│   │       ├── config.json.example
│   │       ├── config.py
│   │       ├── demo_dynamic_sources.py
│   │       └── rss_parser.py
│   ├── example_users_to_add_no_tz.csv
│   └── sftp_upload_with_id
│       ├── Api.py
│       ├── config_ftp.json.example
│       ├── config.py
│       ├── demo_upload.py
│       ├── language.py
│       └── requirements.txt
├── images
│   ├── alternative mcp client.png
│   ├── favicon
│   │   ├── android-chrome-192x192.png
│   │   ├── android-chrome-512x512.png
│   │   ├── apple-touch-icon.png
│   │   ├── favicon-16x16.png
│   │   ├── favicon-32x32.png
│   │   ├── favicon.ico
│   │   └── site.webmanifest
│   ├── mcp-general-architecture.png
│   ├── privateGPT-MCP.png
│   └── privateGPT.png
├── InstallMPCServer.sh
├── jest.config.js
├── LICENSE
├── package.json
├── pgpt.env.json.example
├── README.md
├── security
│   ├── generate_decrypted_password.js
│   └── generate_encrypted_password.js
├── src
│   ├── helper.js
│   ├── index.js
│   ├── logger.js
│   ├── pgpt-messages.js
│   ├── public
│   │   ├── index.html
│   │   └── pgpt-mcp-logo.png
│   ├── services
│   │   └── pgpt-service.ts
│   └── types
│       └── api.ts
├── start_chatbot_agent.ps1
├── start_chatbot_agent.sh
├── start_iot_agent.ps1
├── start_iot_agent.sh
├── start_openai_compatible_api_agent.ps1
├── start_openai_compatible_api_agent.sh
├── tsconfig.json
├── ver
│   ├── index_np.js
│   └── index_proxy_np.js
└── WORKLOG.md
```

# Files

--------------------------------------------------------------------------------
/clients/C# .Net/2.1 mcp_continue_chat/obj/Debug/net9.0/mcp_continue_chat.csproj.FileListAbsolute.txt:
--------------------------------------------------------------------------------

```
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\bin\Debug\net9.0\mcp_continue_chat.exe
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\bin\Debug\net9.0\mcp_continue_chat.deps.json
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\bin\Debug\net9.0\mcp_continue_chat.runtimeconfig.json
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\bin\Debug\net9.0\mcp_continue_chat.dll
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\bin\Debug\net9.0\mcp_continue_chat.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\bin\Debug\net9.0\Newtonsoft.Json.dll
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.csproj.AssemblyReference.cache
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.GeneratedMSBuildEditorConfig.editorconfig
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.AssemblyInfoInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.AssemblyInfo.cs
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.csproj.CoreCompileInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_cont.EF178231.Up2Date
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.dll
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\refint\mcp_continue_chat.dll
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\mcp_continue_chat.genruntimeconfig.cache
C:\Users\uwuertz\AI\mcp-client\mcp_continue_chat\obj\Debug\net9.0\ref\mcp_continue_chat.dll

```

--------------------------------------------------------------------------------
/clients/C# .Net/2.2 mcp_get_chat_info/obj/Debug/net9.0/mcp_get_chat_info.csproj.FileListAbsolute.txt:
--------------------------------------------------------------------------------

```
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\bin\Debug\net9.0\mcp_get_chat_info.exe
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\bin\Debug\net9.0\mcp_get_chat_info.deps.json
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\bin\Debug\net9.0\mcp_get_chat_info.runtimeconfig.json
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\bin\Debug\net9.0\mcp_get_chat_info.dll
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\bin\Debug\net9.0\mcp_get_chat_info.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\bin\Debug\net9.0\Newtonsoft.Json.dll
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.csproj.AssemblyReference.cache
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.GeneratedMSBuildEditorConfig.editorconfig
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.AssemblyInfoInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.AssemblyInfo.cs
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.csproj.CoreCompileInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_.DFF47B4E.Up2Date
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.dll
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\refint\mcp_get_chat_info.dll
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\mcp_get_chat_info.genruntimeconfig.cache
C:\Users\uwuertz\AI\mcp-client\mcp_get_chat_info\obj\Debug\net9.0\ref\mcp_get_chat_info.dll

```

--------------------------------------------------------------------------------
/clients/C# .Net/3.0 mcp_create_source/obj/Debug/net9.0/mcp_create_source.csproj.FileListAbsolute.txt:
--------------------------------------------------------------------------------

```
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\bin\Debug\net9.0\mcp_create_source.exe
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\bin\Debug\net9.0\mcp_create_source.deps.json
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\bin\Debug\net9.0\mcp_create_source.runtimeconfig.json
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\bin\Debug\net9.0\mcp_create_source.dll
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\bin\Debug\net9.0\mcp_create_source.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\bin\Debug\net9.0\Newtonsoft.Json.dll
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.csproj.AssemblyReference.cache
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.GeneratedMSBuildEditorConfig.editorconfig
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.AssemblyInfoInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.AssemblyInfo.cs
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.csproj.CoreCompileInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_crea.CB4ED912.Up2Date
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.dll
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\refint\mcp_create_source.dll
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\mcp_create_source.genruntimeconfig.cache
C:\Users\uwuertz\AI\mcp-client\mcp_create_source\obj\Debug\net9.0\ref\mcp_create_source.dll

```

--------------------------------------------------------------------------------
/clients/C# .Net/3.4 mcp_delete_source/obj/Debug/net9.0/mcp_delete_source.csproj.FileListAbsolute.txt:
--------------------------------------------------------------------------------

```
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\bin\Debug\net9.0\mcp_delete_source.exe
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\bin\Debug\net9.0\mcp_delete_source.deps.json
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\bin\Debug\net9.0\mcp_delete_source.runtimeconfig.json
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\bin\Debug\net9.0\mcp_delete_source.dll
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\bin\Debug\net9.0\mcp_delete_source.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\bin\Debug\net9.0\Newtonsoft.Json.dll
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.csproj.AssemblyReference.cache
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.GeneratedMSBuildEditorConfig.editorconfig
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.AssemblyInfoInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.AssemblyInfo.cs
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.csproj.CoreCompileInputs.cache
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_dele.67DD13F9.Up2Date
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.dll
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\refint\mcp_delete_source.dll
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.pdb
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\mcp_delete_source.genruntimeconfig.cache
C:\Users\uwuertz\AI\mcp-client\mcp_delete_source\obj\Debug\net9.0\ref\mcp_delete_source.dll

```

--------------------------------------------------------------------------------
/agents/OpenAI_Compatible_API_Agent/Python/client_tests/vllm_client_multimodal.py:
--------------------------------------------------------------------------------

```python
import argparse
import base64
import io

import httpx
from PIL import Image
from openai import OpenAI

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Provide an API key to connect to OpenAI-compatible API.")
    parser.add_argument("--api_key", required=True, help="API key for login")
    parser.add_argument("--base_url", required=True, help="The base url of the VLLM server")
    args = parser.parse_args()

    client = OpenAI(
        base_url=args.base_url,
        api_key=args.api_key,
        http_client=httpx.Client(verify=False)
    )

    from openai import OpenAI

    # for local file:
    image = Image.open("Python/client_tests/japan.jpg")
    # Convert the image to a byte stream
    buffered = io.BytesIO()
    image.save(buffered, format="JPEG")  # Specify the format (e.g., JPEG, PNG)
    image_bytes = buffered.getvalue()
    image_base64 = base64.b64encode(image_bytes).decode("utf-8")
    # local file end

    chat_response = client.chat.completions.create(
        model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {

                        "url": f"data:image/jpeg;base64,{image_base64}"
                        #or simply:
                        #"url": "https://www.urlaubstracker.de/wp-content/uploads/2019/03/japan-fuji-himeji-castle.jpg",

                    },
                },
            ],
        }],
    )
    print("Chat response:", chat_response.choices[0].message.content)
```

--------------------------------------------------------------------------------
/agents/MCP-Client/Python/config.py:
--------------------------------------------------------------------------------

```python
# config.py
import json
import logging


from .transport.stdio.stdio_server_parameters import StdioServerParameters


async def load_config(config_path: str, server_name: str) -> StdioServerParameters:
    """Load the server configuration from a JSON file."""
    try:
        # debug
        logging.debug(f"Loading config from {config_path}")

        # Read the configuration file
        with open(config_path, "r") as config_file:
            config = json.load(config_file)

        # Retrieve the server configuration
        server_config = config.get("mcpServers", {}).get(server_name)
        if not server_config:
            error_msg = f"Server '{server_name}' not found in configuration file."
            logging.error(error_msg)
            raise ValueError(error_msg)

        # Construct the server parameters
        result = StdioServerParameters(
            command=server_config["command"],
            args=server_config.get("args", []),
            env=server_config.get("env"),
        )


        # debug
        logging.debug(
            f"Loaded config: command='{result.command}', args={result.args}, env={result.env}"
        )

        # return result
        return result

    except FileNotFoundError:
        # error
        error_msg = f"Configuration file not found: {config_path}"
        logging.error(error_msg)
        raise FileNotFoundError(error_msg)
    except json.JSONDecodeError as e:
        # json error
        error_msg = f"Invalid JSON in configuration file: {e.msg}"
        logging.error(error_msg)
        raise json.JSONDecodeError(error_msg, e.doc, e.pos)
    except ValueError as e:
        # error
        logging.error(str(e))
        raise

```

--------------------------------------------------------------------------------
/clients/C# .Net/4.0 mcp_list_groups/obj/Debug/net9.0/mcp_list_groups.csproj.FileListAbsolute.txt:
--------------------------------------------------------------------------------

```
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\bin\Debug\net9.0\mcp_list_groups.exe
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\bin\Debug\net9.0\mcp_list_groups.deps.json
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\bin\Debug\net9.0\mcp_list_groups.runtimeconfig.json
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\bin\Debug\net9.0\mcp_list_groups.dll
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\bin\Debug\net9.0\mcp_list_groups.pdb
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\bin\Debug\net9.0\Newtonsoft.Json.dll
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.csproj.AssemblyReference.cache
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.GeneratedMSBuildEditorConfig.editorconfig
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.AssemblyInfoInputs.cache
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.AssemblyInfo.cs
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.csproj.CoreCompileInputs.cache
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list.EBD5E0D2.Up2Date
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.dll
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\refint\mcp_list_groups.dll
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.pdb
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\mcp_list_groups.genruntimeconfig.cache
C:\Users\uwuertz\AI\mcp-client\C# .Net\mcp_list_groups\obj\Debug\net9.0\ref\mcp_list_groups.dll

```

--------------------------------------------------------------------------------
/src/types/api.ts:
--------------------------------------------------------------------------------

```typescript
export interface ChatArgs {
  question: string;
  usePublic?: boolean;
  groups?: string[];
  language?: string;
}

export interface SourceArgs {
  name: string;
  content: string;
  groups?: string[];
}

export interface ListSourcesArgs {
  groupName: string;
}

export interface GetSourceArgs {
  sourceId: string;
}

export function validateChatArgs(args: Record<string, unknown> | undefined): ChatArgs {
  if (!args?.question || typeof args.question !== 'string') {
    throw new Error('Missing or invalid question');
  }

  return {
    question: args.question,
    usePublic: typeof args.usePublic === 'boolean' ? args.usePublic : false,
    groups: Array.isArray(args.groups) ? args.groups.map(String) : [],
    language: typeof args.language === 'string' ? args.language : 'en',
  };
}

export function validateSourceArgs(args: Record<string, unknown> | undefined): SourceArgs {
  if (!args?.name || typeof args.name !== 'string') {
    throw new Error('Missing or invalid name');
  }
  if (!args?.content || typeof args.content !== 'string') {
    throw new Error('Missing or invalid content');
  }

  return {
    name: args.name,
    content: args.content,
    groups: Array.isArray(args.groups) ? args.groups.map(String) : [],
  };
}

export function validateListSourcesArgs(args: Record<string, unknown> | undefined): ListSourcesArgs {
  if (!args?.groupName || typeof args.groupName !== 'string') {
    throw new Error('Missing or invalid groupName');
  }

  return {
    groupName: args.groupName,
  };
}

export function validateGetSourceArgs(args: Record<string, unknown> | undefined): GetSourceArgs {
  if (!args?.sourceId || typeof args.sourceId !== 'string') {
    throw new Error('Missing or invalid sourceId');
  }

  return {
    sourceId: args.sourceId,
  };
}

```

--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "pgpt-mcp-server",
  "version": "2.1.0",
  "description": "PrivateGPT MCP Server",
  "main": "dist/index.js",
  "type": "module",
  "scripts": {
    "build": "tsc && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
    "start": "node dist/index.js",
    "dev": "ts-node --esm src/index.ts",
    "test": "jest",
    "lint": "eslint . --ext .ts",
    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
    "postinstall": "patch-package"
  },
  "keywords": [
    "mcp",
    "privategpt"
  ],
  "author": "",
  "license": "MIT",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.4.1",
    "@remote-mcp/client": "^0.1.0",
    "@remote-mcp/server": "^0.1.0",
    "@trpc/client": "^11.0.0-rc.730",
    "axios": "^1.7.9",
    "chalk": "^5.4.1",
    "chokidar": "^4.0.3",
    "content-type": "^1.0.5",
    "dotenv": "^16.4.7",
    "express": "^4.21.2",
    "figlet": "^1.8.0",
    "moment": "^2.30.1",
    "raw-body": "^3.0.0",
    "socket.io": "^4.8.1",
    "strip-ansi": "^7.1.0",
    "winston": "^3.17.0",
    "xmlhttprequest": "^1.8.0",
    "zod": "^3.24.1"
  },
  "devDependencies": {
    "@types/content-type": "^1.1.8",
    "@types/jest": "^29.5.14",
    "@types/node": "^22.10.5",
    "@typescript-eslint/eslint-plugin": "^8.19.1",
    "@typescript-eslint/parser": "^8.19.1",
    "eslint": "^9.18.0",
    "eslint-config-prettier": "^9.1.0",
    "eslint-plugin-prettier": "^5.2.1",
    "jest": "^29.7.0",
    "patch-package": "^8.0.0",
    "postinstall-postinstall": "^2.1.0",
    "prettier": "^3.4.2",
    "ts-jest": "^29.2.5",
    "ts-node": "^10.9.2",
    "typescript": "^5.7.3"
  },
  "engines": {
    "node": ">=18.0.0"
  },
  "overrides": {
    "glob": "^9.3.5",
    "rimraf": "^5.0.1"
  },
  "resolutions": {
    "glob": "^9.3.5",
    "rimraf": "^5.0.1"
  }
}

```

--------------------------------------------------------------------------------
/security/generate_encrypted_password.js:
--------------------------------------------------------------------------------

```javascript
import fs from 'fs';
import crypto from 'crypto';
import readline from 'readline';

// Function to read the public key
function loadPublicKey(path) {
    if (!path) {
        throw new Error(
            `No public key path provided. Please specify the path to the RSA-public key as an argument.
                        Example usage: node security/generate_encrypted_password.js ~/.ssh/id_rsa_public.pem`
        );
    }

    try {
        return fs.readFileSync(path, 'utf8');
    } catch (err) {
        throw new Error(`Error reading public key at "${path}": ${err.message}`);
    }
}

// Function for encryption
function encryptWithPublicKey(data, publicKey) {
    return crypto.publicEncrypt(
        {
            key: publicKey,
            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING
            //padding: crypto.constants.RSA_PKCS1_PADDING, // Explicitly set padding
        },
        Buffer.from(data)
    ).toString('base64');
}

// Prompt for password
function askPassword(question) {
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
    });

    return new Promise((resolve) => {
        rl.question(question, (answer) => {
            rl.close();
            resolve(answer);
        });
    });
}

// Main function
async function main() {
    const publicKeyPath = process.argv[2]; // Get the public key path from command-line arguments

    try {
        const publicKey = loadPublicKey(publicKeyPath); // Load the public key
        const password = await askPassword('Please enter your password: '); // Prompt for the password
        const encryptedPassword = encryptWithPublicKey(password, publicKey); // Encrypt the password
        console.log('Encrypted Password:', encryptedPassword);
    } catch (err) {
        console.error('Error:', err.message);
    }
}

main();
```

--------------------------------------------------------------------------------
/agents/OpenAI_Compatible_API_Agent/Python/client_tests/vllm_structured2.py:
--------------------------------------------------------------------------------

```python
import argparse
import json
import httpx
from openai import OpenAI

character_schema = {'name': 'characters', 'type': 'object',
                    'properties': {"characters": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "occupation": {"type": "string"},
                                "personality": {"type": "string"},
                                "background": {"type": "string"}
                            },
                            "required": ["name", "occupation", "personality", "background"]
                        },
                        "minItems": 1,
                    }
                },
                "required": ["characters"],
                }



print(character_schema)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Provide an API key to connect to OpenAI-compatible API.")
    parser.add_argument("--api_key", required=True, help="API key for login")
    parser.add_argument("--base_url", required=True, help="The base url of the VLLM server")
    args = parser.parse_args()


    client = OpenAI(
        base_url=args.base_url,
        api_key=args.api_key,
        http_client=  httpx.Client(verify=False)
    )

    completion = client.chat.completions.create(
        model="/models/mistral-nemo-12b",
        messages=[
            {
                "role": "user",
                "content": "Generate a JSON with 5-10 fictional characters working at Fujitsu",
            }
        ],
        extra_body={"guided_json": character_schema},
    )
    try:
        results = json.loads(completion.choices[0].message.content)
        print(json.dumps(results, indent=2))
    except:
        print(completion.choices[0].message.content)
```

--------------------------------------------------------------------------------
/clients/Gradio/mcp_servers/demo-mcp-server/demo-tools-sse.js:
--------------------------------------------------------------------------------

```javascript
import express from "express";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";

import { z } from "zod";

import {calculator_sse} from "./tools/calculator.js"
import {weather} from "./tools/weather.js"
import {bitcoin, gold} from "./tools/assets.js"


var transport = null

const server = new McpServer({
  name: "demo-tools-sse",
  version: "0.0.1"
});

await add_tool("calculator",
         "Perform basic calculations. Add, subtract, multiply, divide. Invoke this tool every time you need to perform a calculation.",
         {expression: z.string()},
         calculator_sse)

await add_tool("get_weather",
         "Fetch the current weather for a specific location. Invoke this tool every time you need to give information on the weather.",
        {location: z.string()},
         weather)

await add_tool("get_gold_price",
         "Get the current price of Gold. Invoke this every time the user asks for the price of Gold",
         {},
         gold)

await add_tool("get_bitcoin_price",
         "Get the current price of Bitcoin. Invoke this every time the user asks for the price of Bitcoin",
         {},
         bitcoin)

async function add_tool(name, description, schema, func){
// Add tool will add the tool to both, local and remote access systems
    server.tool(name, description, schema,
        async (args) => {
            return await func(args)
        });
}


const app = express();

app.get("/sse", async (req, res) => {
  transport = new SSEServerTransport("/messages", res);
  await server.connect(transport);
});

app.post("/messages", async (req, res) => {
  // Note: to support multiple simultaneous connections, these messages will
  // need to be routed to a specific matching transport. (This logic isn't
  // implemented here, for simplicity.)
  await transport.handlePostMessage(req, res);
});

app.listen(3001);
```

--------------------------------------------------------------------------------
/clients/Go/9.0 mcp_keygen/MCPKeygenClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type KeygenPayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendKeygenRequest(serverIP string, serverPort int, token, password string) (string, error) {
	// Prepare the request payload
	payload := KeygenPayload{
		Command: "keygen",
		Token:   token,
		Arguments: map[string]interface{}{
			"password": password,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	password := flag.String("password", "", "Password to send for key generation")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *password == "" {
		fmt.Println("❌ ERROR: Required flags are missing.")
		flag.Usage()
		os.Exit(1)
	}

	// Send the keygen request
	fmt.Println("📤 Sending keygen request...")
	response, err := sendKeygenRequest(*serverIP, *serverPort, *token, *password)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}
```

--------------------------------------------------------------------------------
/clients/Go/5.2 mcp_delete_user/MCPDeleteUserClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type DeleteUserPayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendDeleteUserRequest(serverIP string, serverPort int, email, token string) (string, error) {
	// Prepare the request payload
	payload := DeleteUserPayload{
		Command: "delete_user",
		Token:   token,
		Arguments: map[string]interface{}{
			"email": email,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	email := flag.String("email", "", "Email of the user to delete")
	token := flag.String("token", "", "Authentication token")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *email == "" || *token == "" {
		fmt.Println("❌ ERROR: Required flags are missing.")
		flag.Usage()
		os.Exit(1)
	}

	// Send the request to delete the user
	fmt.Println("📤 Sending request to delete user...")
	response, err := sendDeleteUserRequest(*serverIP, *serverPort, *email, *token)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/Gradio/mcp_servers/replicate_flux/server.py:
--------------------------------------------------------------------------------

```python
import os

import PIL
import requests
from mcp.server.fastmcp import FastMCP, Image
import json
import sys
import io
from PIL import Image as PilImage
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')

mcp = FastMCP("Generate images with Flux")


@mcp.tool()
async def generate_image(prompt: str, ratio: str = "1:1") ->  str:
    """Generate an image using Flux model.

    Args:
        prompt: Text prompt describing the image to generate
        ratio: Image ratio (default: 1:1)
    """
    try:
        import replicate

        output = replicate.run(
            "black-forest-labs/flux-1.1-pro",
            input={"prompt": prompt,
                   "aspect_ratio": ratio,
                   "output_format": "jpg",
                   "output_quality": 80,
                   "safety_tolerance": 2,
                   "prompt_upsampling": True
                   }
        )
        #print(output)
        return json.dumps({
            "type": "image",
            "url": str(output),
            "message": f"Generated image: {str(prompt)}"
        })

        #response = requests.get(output, verify=False)
        #img = PilImage.open(io.BytesIO(response.content))
        #img.save("image.jpg")
        #return Image(data=img.tobytes(), format='jpeg')


    except Exception as e:
        print("Error: " + str(e))
        return json.dumps({
            "type": "error",
            "message": f"Error generating image: {str(e)}"
        })


if __name__ == "__main__":

    import asyncio
    img = asyncio.run(generate_image("A yellow bird"))
    j = json.loads(img)
    print("getting image:" + j.get("url"))

    response = requests.get(j.get("url"), verify=False)
    print("opening image")
    image = PilImage.open(io.BytesIO(response.content)).convert("RGB")
    image.save("image.jpg")

```

--------------------------------------------------------------------------------
/clients/Go/3.4 mcp_delete_source/MCPDeleteSourceClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type DeleteSourcePayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func deleteSource(serverIP string, serverPort int, token, sourceID string) (string, error) {
	// Prepare the request payload
	payload := DeleteSourcePayload{
		Command: "delete_source",
		Token:   token,
		Arguments: map[string]interface{}{
			"sourceId": sourceID,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authorization token")
	sourceID := flag.String("source-id", "", "ID of the source to delete")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *sourceID == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	// Send the request to delete the source
	fmt.Println("📤 Sending request to delete source...")
	response, err := deleteSource(*serverIP, *serverPort, *token, *sourceID)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/Go/3.1 mcp_get_source/MCPGetSourceClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type GetSourcePayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func getSourceInformation(serverIP string, serverPort int, token, sourceID string) (string, error) {
	// Prepare the request payload
	payload := GetSourcePayload{
		Command: "get_source",
		Token:   token,
		Arguments: map[string]interface{}{
			"sourceId": sourceID,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	sourceID := flag.String("source-id", "", "ID of the source to retrieve")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *sourceID == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	// Retrieve the source information
	fmt.Println("📤 Sending request to retrieve source information...")
	response, err := getSourceInformation(*serverIP, *serverPort, *token, *sourceID)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/Go/4.2 mcp_delete_group/MCPDeleteGroupClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type DeleteGroupPayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendDeleteGroupRequest(serverIP string, serverPort int, token, groupName string) (string, error) {
	// Prepare the request payload
	payload := DeleteGroupPayload{
		Command: "delete_group",
		Token:   token,
		Arguments: map[string]interface{}{
			"groupName": groupName,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	groupName := flag.String("group-name", "", "Name of the group to delete")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *groupName == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	// Send the request to delete the group
	fmt.Println("📤 Sending request to delete group...")
	response, err := sendDeleteGroupRequest(*serverIP, *serverPort, *token, *groupName)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/Go/3.2 mcp_list_sources/MCPListSourcesClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type ListSourcesPayload struct {
	Command    string                 `json:"command"`
	Token      string                 `json:"token"`
	Attributes map[string]interface{} `json:"attributes"`
}

func sendListSourcesRequest(serverIP string, serverPort int, token, groupName string) (string, error) {
	// Prepare the request payload
	payload := ListSourcesPayload{
		Command: "list_sources",
		Token:   token,
		Attributes: map[string]interface{}{
			"groupName": groupName,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	groupName := flag.String("group-name", "", "Name of the group to list sources from")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *groupName == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	// Send the request to list sources
	fmt.Println("📤 Sending request to list sources...")
	response, err := sendListSourcesRequest(*serverIP, *serverPort, *token, *groupName)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/2.0 mcp_chat/obj/mcp_chat.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_chat\\mcp_chat.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_chat\\mcp_chat.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_chat\\mcp_chat.csproj",
        "projectName": "mcp_chat",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_chat\\mcp_chat.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_chat\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/1.0 mcp_login/obj/mcp_login.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_login\\mcp_login.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_login\\mcp_login.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_login\\mcp_login.csproj",
        "projectName": "mcp_login",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_login\\mcp_login.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_login\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/Go/4.0 mcp_list_groups/MCPListGroupsClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type ListGroupsPayload struct {
	Command string `json:"command"`
	Token   string `json:"token"`
}

func sendRequest(serverIP string, serverPort int, payload ListGroupsPayload) (map[string]interface{}, error) {
	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return nil, err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return nil, err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return nil, err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	// Decode the response
	var response map[string]interface{}
	err = json.Unmarshal(responseBuffer.Bytes(), &response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

func listGroups(serverIP string, serverPort int, token string) (map[string]interface{}, error) {
	payload := ListGroupsPayload{
		Command: "list_groups",
		Token:   token,
	}
	return sendRequest(serverIP, serverPort, payload)
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token for the MCP server")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	fmt.Println("📄 Fetching groups...")
	response, err := listGroups(*serverIP, *serverPort, *token)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	responseJSON, err := json.MarshalIndent(response, "", "  ")
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response:")
	fmt.Println(string(responseJSON))
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/1.1 mcp_logout/obj/mcp_logout.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_logout\\mcp_logout.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_logout\\mcp_logout.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_logout\\mcp_logout.csproj",
        "projectName": "mcp_logout",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_logout\\mcp_logout.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_logout\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/agents/MCP-Client/Python/messages/send_message.py:
--------------------------------------------------------------------------------

```python
# messages/send_message.py
import logging
import anyio
from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
from .message_types.json_rpc_message import JSONRPCMessage

async def send_message(
    read_stream: MemoryObjectReceiveStream,
    write_stream: MemoryObjectSendStream,
    message: JSONRPCMessage,
    timeout: float = 5,
    retries: int = 3,
) -> dict:
    """
    Send a JSON-RPC message to the server and return the response.

    Args:
        read_stream (MemoryObjectReceiveStream): The stream to read responses.
        write_stream (MemoryObjectSendStream): The stream to send requests.
        message (JSONRPCMessage): The JSON-RPC message to send.
        timeout (float): Timeout in seconds to wait for a response.
        retries (int): Number of retry attempts.

    Returns:
        dict: The server's response as a dictionary.

    Raises:
        TimeoutError: If no response is received within the timeout.
        Exception: If an unexpected error occurs.
    """
    for attempt in range(1, retries + 1):
        try:
            logging.debug(f"Attempt {attempt}/{retries}: Sending message: {message}")
            await write_stream.send(message)

            with anyio.fail_after(timeout):
                async for response in read_stream:
                    if not isinstance(response, Exception):
                        logging.debug(f"Received response: {response.model_dump()}")
                        return response.model_dump()
                    else:
                        logging.error(f"Server error: {response}")
                        raise response

        except TimeoutError:
            logging.error(
                f"Timeout waiting for response to message '{message.method}' (Attempt {attempt}/{retries})"
            )
            if attempt == retries:
                raise
        except Exception as e:
            logging.error(
                f"Unexpected error during '{message.method}' request: {e} (Attempt {attempt}/{retries})"
            )
            if attempt == retries:
                raise

        await anyio.sleep(2)

```

--------------------------------------------------------------------------------
/clients/Gradio/messages/send_message.py:
--------------------------------------------------------------------------------

```python
# messages/send_message.py
import logging
import anyio
from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
from .message_types.json_rpc_message import JSONRPCMessage

async def send_message(
    read_stream: MemoryObjectReceiveStream,
    write_stream: MemoryObjectSendStream,
    message: JSONRPCMessage,
    timeout: float = 15,
    retries: int = 50,
) -> dict:
    """
    Send a JSON-RPC message to the server and return the response.

    Args:
        read_stream (MemoryObjectReceiveStream): The stream to read responses.
        write_stream (MemoryObjectSendStream): The stream to send requests.
        message (JSONRPCMessage): The JSON-RPC message to send.
        timeout (float): Timeout in seconds to wait for a response.
        retries (int): Number of retry attempts.

    Returns:
        dict: The server's response as a dictionary.

    Raises:
        TimeoutError: If no response is received within the timeout.
        Exception: If an unexpected error occurs.
    """
    for attempt in range(1, retries + 1):
        try:
            logging.debug(f"Attempt {attempt}/{retries}: Sending message: {message}")
            await write_stream.send(message)

            with anyio.fail_after(timeout):
                async for response in read_stream:
                    if not isinstance(response, Exception):
                        logging.debug(f"Received response: {response.model_dump()}")
                        return response.model_dump()
                    else:
                        logging.error(f"Server error: {response}")
                        raise response

        except TimeoutError:
            logging.error(
                f"Timeout waiting for response to message '{message.method}' (Attempt {attempt}/{retries})"
            )
            if attempt == retries:
                raise
        except Exception as e:
            logging.error(
                f"Unexpected error during '{message.method}' request: {e} (Attempt {attempt}/{retries})"
            )
            if attempt == retries:
                raise

        await anyio.sleep(2)

```

--------------------------------------------------------------------------------
/clients/Go/1.0 mcp_login/MCPLoginClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type Payload struct {
	Command   string                 `json:"command"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendRequest(serverIP string, serverPort int, payload Payload) (map[string]interface{}, error) {
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return nil, err
	}
	defer conn.Close()

	_, err = conn.Write(payloadJSON)
	if err != nil {
		return nil, err
	}

	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return nil, err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	var response map[string]interface{}
	err = json.Unmarshal(responseBuffer.Bytes(), &response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

func login(serverIP string, serverPort int, email, password string) (map[string]interface{}, error) {
	payload := Payload{
		Command: "login",
		Arguments: map[string]interface{}{
			"email":    email,
			"password": password,
		},
	}

	return sendRequest(serverIP, serverPort, payload)
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	email := flag.String("email", "", "Email address for login")
	password := flag.String("password", "", "Password for login")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *email == "" || *password == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	fmt.Println("🔐 Logging in...")
	response, err := login(*serverIP, *serverPort, *email, *password)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	responseJSON, err := json.MarshalIndent(response, "", "  ")
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✅ Server Response:")
	fmt.Println(string(responseJSON))
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/5.1 mcp_edit_user/obj/mcp_edit_user.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_edit_user\\mcp_edit_user.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_edit_user\\mcp_edit_user.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_edit_user\\mcp_edit_user.csproj",
        "projectName": "mcp_edit_user",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_edit_user\\mcp_edit_user.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_edit_user\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/Go/2.1 mcp_continue_chat/MCPChatContinuationClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type ContinueChatPayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendContinueChatRequest(serverIP string, serverPort int, token, conversationID, message string) (string, error) {
	// Prepare the request payload
	payload := ContinueChatPayload{
		Command: "continue_chat",
		Token:   token,
		Arguments: map[string]interface{}{
			"chatId":   conversationID,
			"question": message,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	conversationID := flag.String("conversation-id", "", "ID of the chat to continue")
	message := flag.String("message", "", "Message to send in the chat")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *conversationID == "" || *message == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	fmt.Println("💬 Sending request to continue the chat...")
	response, err := sendContinueChatRequest(*serverIP, *serverPort, *token, *conversationID, *message)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✅ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/3.1 mcp_get_source/obj/mcp_get_source.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_source\\mcp_get_source.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_source\\mcp_get_source.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_source\\mcp_get_source.csproj",
        "projectName": "mcp_get_source",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_source\\mcp_get_source.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_source\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/5.0 mcp_store_user/obj/mcp_store_user.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_user\\mcp_store_user.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_user\\mcp_store_user.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_user\\mcp_store_user.csproj",
        "projectName": "mcp_store_user",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_user\\mcp_store_user.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_user\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/4.1 mcp_store_group/obj/mcp_store_group.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_group\\mcp_store_group.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_group\\mcp_store_group.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_group\\mcp_store_group.csproj",
        "projectName": "mcp_store_group",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_group\\mcp_store_group.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_store_group\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/5.2 mcp_delete_user/obj/mcp_delete_user.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_user\\mcp_delete_user.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_user\\mcp_delete_user.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_user\\mcp_delete_user.csproj",
        "projectName": "mcp_delete_user",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_user\\mcp_delete_user.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_user\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/Go/4.1 mcp_store_group/MCPStoreGroupClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type StoreGroupPayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendStoreGroupRequest(serverIP string, serverPort int, groupName, token, description string) (string, error) {
	// Prepare the request payload
	payload := StoreGroupPayload{
		Command: "store_group",
		Token:   token,
		Arguments: map[string]interface{}{
			"groupName":   groupName,
			"description": description,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	groupName := flag.String("group-name", "", "Name of the group to store")
	token := flag.String("token", "", "Authentication token")
	description := flag.String("description", "", "Description of the group (optional)")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *groupName == "" || *token == "" {
		fmt.Println("❌ ERROR: Required flags are missing.")
		flag.Usage()
		os.Exit(1)
	}

	// Send the request to store the group
	fmt.Println("📤 Sending request to store group...")
	response, err := sendStoreGroupRequest(*serverIP, *serverPort, *groupName, *token, *description)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/3.2 mcp_list_sources/obj/mcp_list_sources.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_list_sources\\mcp_list_sources.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_list_sources\\mcp_list_sources.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_list_sources\\mcp_list_sources.csproj",
        "projectName": "mcp_list_sources",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_list_sources\\mcp_list_sources.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_list_sources\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/4.2 mcp_delete_group/obj/mcp_delete_group.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_group\\mcp_delete_group.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_group\\mcp_delete_group.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_group\\mcp_delete_group.csproj",
        "projectName": "mcp_delete_group",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_group\\mcp_delete_group.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_group\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/2.1 mcp_continue_chat/obj/mcp_continue_chat.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_continue_chat\\mcp_continue_chat.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_continue_chat\\mcp_continue_chat.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_continue_chat\\mcp_continue_chat.csproj",
        "projectName": "mcp_continue_chat",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_continue_chat\\mcp_continue_chat.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_continue_chat\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/2.2 mcp_get_chat_info/obj/mcp_get_chat_info.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_chat_info\\mcp_get_chat_info.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_chat_info\\mcp_get_chat_info.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_chat_info\\mcp_get_chat_info.csproj",
        "projectName": "mcp_get_chat_info",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_chat_info\\mcp_get_chat_info.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_get_chat_info\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/3.0 mcp_create_source/obj/mcp_create_source.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_create_source\\mcp_create_source.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_create_source\\mcp_create_source.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_create_source\\mcp_create_source.csproj",
        "projectName": "mcp_create_source",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_create_source\\mcp_create_source.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_create_source\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/3.4 mcp_delete_source/obj/mcp_delete_source.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_source\\mcp_delete_source.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_source\\mcp_delete_source.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_source\\mcp_delete_source.csproj",
        "projectName": "mcp_delete_source",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_source\\mcp_delete_source.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\mcp_delete_source\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/agents/OpenAI_Compatible_API_Agent/Python/client_tests/openai_test_client_tools.py:
--------------------------------------------------------------------------------

```python
import argparse
import json
from enum import Enum
from typing import Union

from pydantic import BaseModel

import openai
from openai import OpenAI


class Table(str, Enum):
    orders = "orders"
    customers = "customers"
    products = "products"


class Column(str, Enum):
    id = "id"
    status = "status"
    expected_delivery_date = "expected_delivery_date"
    delivered_at = "delivered_at"
    shipped_at = "shipped_at"
    ordered_at = "ordered_at"
    canceled_at = "canceled_at"


class Operator(str, Enum):
    eq = "="
    gt = ">"
    lt = "<"
    le = "<="
    ge = ">="
    ne = "!="


class OrderBy(str, Enum):
    asc = "asc"
    desc = "desc"


class DynamicValue(BaseModel):
    column_name: str


class Condition(BaseModel):
    column: str
    operator: Operator
    value: Union[str, int, DynamicValue]


class Query(BaseModel):
    table_name: Table
    columns: list[Column]
    conditions: list[Condition]
    order_by: OrderBy

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Provide an API key to connect to OpenAI-compatible API.")
    parser.add_argument("--api_key", required=True, help="API key for login")
    args = parser.parse_args()

    stream = True
    client = OpenAI(
        base_url="http://localhost:8001/",
        api_key=args.api_key
    )
    completion = client.beta.chat.completions.parse(
        model="pgpt",
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant. The current date is August 6, 2025. You help users query for the data they are looking for by calling the query function.",
            },
            {
                "role": "user",
                "content": "look up all my orders in may of last year that were fulfilled but not delivered on time",
            },
        ],
        tools=[
            openai.pydantic_function_tool(Query),
        ],
        extra_body={
            "groups": [],
            "newSession": True
        }
    )

    try:
        results = json.loads(completion.choices[0].message.content)
        print(json.dumps(results, indent=2))
    except:
        print(completion.choices[0].message.content)
```

--------------------------------------------------------------------------------
/clients/C# .Net/1.1 mcp_logout/Program.cs:
--------------------------------------------------------------------------------

```csharp
using System;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;

class Program
{
    static void Main(string[] args)
    {
        string serverIp = null;
        int serverPort = 0;
        string token = null;

        // Argumente parsen
        for (int i = 0; i < args.Length; i++)
        {
            switch (args[i])
            {
                case "--server-ip":
                    serverIp = args[++i];
                    break;
                case "--server-port":
                    serverPort = int.Parse(args[++i]);
                    break;
                case "--token":
                    token = args[++i];
                    break;
            }
        }

        // Überprüfen, ob alle Argumente angegeben wurden
        if (string.IsNullOrEmpty(serverIp) || serverPort == 0 || string.IsNullOrEmpty(token))
        {
            Console.WriteLine("❌ ERROR: Missing required parameters.");
            return;
        }

        Console.WriteLine("🔒 Sending logout request...");
        string response = SendLogoutRequest(serverIp, serverPort, token);
        Console.WriteLine("Response from server:");
        Console.WriteLine(response);
    }

    static string SendLogoutRequest(string serverIp, int serverPort, string token)
    {
        // Erstelle das JSON-Payload
        var payload = new
        {
            command = "logout",
            token = token
        };

        string payloadJson = JsonConvert.SerializeObject(payload);

        try
        {
            using (var client = new TcpClient(serverIp, serverPort))
            using (var stream = client.GetStream())
            {
                // Sende das Payload
                byte[] data = Encoding.UTF8.GetBytes(payloadJson);
                stream.Write(data, 0, data.Length);

                // Antwort empfangen
                byte[] buffer = new byte[4096];
                int bytesRead = stream.Read(buffer, 0, buffer.Length);

                string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                return response;
            }
        }
        catch (Exception ex)
        {
            return $"Error: {ex.Message}";
        }
    }
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/Code Archiv/mcp_logout.cs:
--------------------------------------------------------------------------------

```csharp
using System;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;

class Program
{
    static void Main(string[] args)
    {
        string serverIp = null;
        int serverPort = 0;
        string token = null;

        // Argumente parsen
        for (int i = 0; i < args.Length; i++)
        {
            switch (args[i])
            {
                case "--server-ip":
                    serverIp = args[++i];
                    break;
                case "--server-port":
                    serverPort = int.Parse(args[++i]);
                    break;
                case "--token":
                    token = args[++i];
                    break;
            }
        }

        // Überprüfen, ob alle Argumente angegeben wurden
        if (string.IsNullOrEmpty(serverIp) || serverPort == 0 || string.IsNullOrEmpty(token))
        {
            Console.WriteLine("❌ ERROR: Missing required parameters.");
            return;
        }

        Console.WriteLine("🔒 Sending logout request...");
        string response = SendLogoutRequest(serverIp, serverPort, token);
        Console.WriteLine("Response from server:");
        Console.WriteLine(response);
    }

    static string SendLogoutRequest(string serverIp, int serverPort, string token)
    {
        // Erstelle das JSON-Payload
        var payload = new
        {
            command = "logout",
            token = token
        };

        string payloadJson = JsonConvert.SerializeObject(payload);

        try
        {
            using (var client = new TcpClient(serverIp, serverPort))
            using (var stream = client.GetStream())
            {
                // Sende das Payload
                byte[] data = Encoding.UTF8.GetBytes(payloadJson);
                stream.Write(data, 0, data.Length);

                // Antwort empfangen
                byte[] buffer = new byte[4096];
                int bytesRead = stream.Read(buffer, 0, buffer.Length);

                string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                return response;
            }
        }
        catch (Exception ex)
        {
            return $"Error: {ex.Message}";
        }
    }
}

```

--------------------------------------------------------------------------------
/clients/Go/2.2 mcp_get_chat_info/MCPGetChatInfoClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type GenericPayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendRequest(serverIP string, serverPort int, payload GenericPayload) (map[string]interface{}, error) {
	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return nil, err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return nil, err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return nil, err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	// Decode the response
	var response map[string]interface{}
	err = json.Unmarshal(responseBuffer.Bytes(), &response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	chatID := flag.String("chat-id", "", "ID of the conversation")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *chatID == "" {
		fmt.Println("❌ ERROR: All flags are required.")
		flag.Usage()
		os.Exit(1)
	}

	// Prepare the payload
	payload := GenericPayload{
		Command: "get_chat_info",
		Token:   *token,
		Arguments: map[string]interface{}{
			"chatId": *chatID,
		},
	}

	fmt.Println("📤 Sending request...")
	response, err := sendRequest(*serverIP, *serverPort, payload)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	responseJSON, err := json.MarshalIndent(response, "", "  ")
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response:")
	fmt.Println(string(responseJSON))
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/4.0 mcp_list_groups/obj/mcp_list_groups.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\mcp_list_groups\\mcp_list_groups.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\mcp_list_groups\\mcp_list_groups.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\mcp_list_groups\\mcp_list_groups.csproj",
        "projectName": "mcp_list_groups",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\mcp_list_groups\\mcp_list_groups.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\mcp_list_groups\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/clients/C# .Net/3.3 mcp_edit_source/obj/mcp_edit_source.csproj.nuget.dgspec.json:
--------------------------------------------------------------------------------

```json
{
  "format": 1,
  "restore": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\3.3 mcp_edit_source\\mcp_edit_source.csproj": {}
  },
  "projects": {
    "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\3.3 mcp_edit_source\\mcp_edit_source.csproj": {
      "version": "1.0.0",
      "restore": {
        "projectUniqueName": "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\3.3 mcp_edit_source\\mcp_edit_source.csproj",
        "projectName": "mcp_edit_source",
        "projectPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\3.3 mcp_edit_source\\mcp_edit_source.csproj",
        "packagesPath": "C:\\Users\\uwuertz\\.nuget\\packages\\",
        "outputPath": "C:\\Users\\uwuertz\\AI\\mcp-client\\C# .Net\\3.3 mcp_edit_source\\obj\\",
        "projectStyle": "PackageReference",
        "configFilePaths": [
          "C:\\Users\\uwuertz\\AppData\\Roaming\\NuGet\\NuGet.Config"
        ],
        "originalTargetFrameworks": [
          "net9.0"
        ],
        "sources": {
          "https://api.nuget.org/v3/index.json": {}
        },
        "frameworks": {
          "net9.0": {
            "targetAlias": "net9.0",
            "projectReferences": {}
          }
        },
        "warningProperties": {
          "warnAsError": [
            "NU1605"
          ]
        },
        "restoreAuditProperties": {
          "enableAudit": "true",
          "auditLevel": "low",
          "auditMode": "direct"
        },
        "SdkAnalysisLevel": "9.0.100"
      },
      "frameworks": {
        "net9.0": {
          "targetAlias": "net9.0",
          "dependencies": {
            "Newtonsoft.Json": {
              "target": "Package",
              "version": "[13.0.3, )"
            }
          },
          "imports": [
            "net461",
            "net462",
            "net47",
            "net471",
            "net472",
            "net48",
            "net481"
          ],
          "assetTargetFallback": true,
          "warn": true,
          "frameworkReferences": {
            "Microsoft.NETCore.App": {
              "privateAssets": "all"
            }
          },
          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.101/PortableRuntimeIdentifierGraph.json"
        }
      }
    }
  }
}
```

--------------------------------------------------------------------------------
/security/generate_decrypted_password.js:
--------------------------------------------------------------------------------

```javascript
import fs from 'fs';
import crypto from 'crypto';
import readline from 'readline';

// Function to load the private key
function loadPrivateKey(path) {
  if (!path) {
    throw new Error(
      `No private key path provided. Please specify the path to the RSA-private key as an argument.
       Example usage: node security/generate_decrypted_password.js ~/.ssh/id_rsa`
    );
  }
  try {
    return fs.readFileSync(path, 'utf8');
  } catch (err) {
    throw new Error(`Error reading private key at "${path}": ${err.message}`);
  }
}

// Function for decryption (uses RSA-OAEP)
function decryptWithPrivateKey(encryptedData, privateKeyPem) {
  const ciphertext = Buffer.from(encryptedData, 'base64');
  const keyObj = crypto.createPrivateKey(privateKeyPem);

  const tryOaep = (hash) =>
    crypto.privateDecrypt(
      {
        key: keyObj,
        padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash: hash, // try sha256 first, sha1 fallback if legacy
      },
      ciphertext
    );

  try {
    return tryOaep('sha256').toString('utf8');
  } catch (e256) {
    try {
      return tryOaep('sha1').toString('utf8');
    } catch (e1) {
      throw new Error(
        `Decryption failed with RSA-OAEP (tried SHA-256 and SHA-1). ` +
          `Ensure the ciphertext was created with RSA-OAEP using the same hash. ` +
          `Errors: [${e256.message}] / [${e1.message}]`
      );
    }
  }
}

// Function to prompt for encrypted password input
function askEncryptedPassword(question) {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: true,
  });
  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      rl.close();
      resolve(answer.trim());
    });
  });
}

// Main function
async function main() {
  const privateKeyPath = process.argv[2]; // private key path as CLI arg

  try {
    const privateKey = loadPrivateKey(privateKeyPath);
    const encryptedPassword = await askEncryptedPassword('Please enter the encrypted password (base64): ');
    const decryptedPassword = decryptWithPrivateKey(encryptedPassword, privateKey);
    console.log('Decrypted Password:', decryptedPassword);
  } catch (err) {
    console.error('Error:', err.message);
    process.exitCode = 1;
  }
}

main();

```

--------------------------------------------------------------------------------
/agents/OpenAI_Compatible_API_Agent/Python/client_tests/openai_test_client_structured.py:
--------------------------------------------------------------------------------

```python
import argparse
from openai import OpenAI
import json

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Provide an API key to connect to OpenAI-compatible API.")
    parser.add_argument("--api_key", required=True, help="API key for login")
    args = parser.parse_args()

    stream = False


    # Initialize OpenAI client that points to the local LM Studio server
    client = OpenAI(
        base_url="http://localhost:8001/",
        api_key=args.api_key
    )

    # Define the conversation with the AI
    messages = [
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "Create 5-10 fictional characters"}
    ]

    # Define the expected response structure
    character_schema = {
        "type": "json_schema",
        "json_schema": {
            "name": "characters",
            "schema": {
                "type": "object",
                "properties": {
                    "characters": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "occupation": {"type": "string"},
                                "personality": {"type": "string"},
                                "background": {"type": "string"}
                            },
                            "required": ["name", "occupation", "personality", "background"]
                        },
                        "minItems": 1,
                    }
                },
                "required": ["characters"]
            },
        }
    }

    # Get response from AI
    response = client.chat.completions.create(
        model="pgpt",
        messages=messages,
        stream=stream,
        response_format=character_schema,
        extra_body={
            "groups": [],
            "newSession": True
        }
    )

    # Parse and display the results
    #print(response.choices[0].message.content)

    if stream:
        for chunk in response:
            print(chunk.choices[0].delta.content or "")

    else:
        results = json.loads(response.choices[0].message.content)
        print(json.dumps(results, indent=2))
```

--------------------------------------------------------------------------------
/clients/Gradio/mcp_servers/moondream/server.py:
--------------------------------------------------------------------------------

```python
import gzip
import io
import os
import sys

import requests
from mcp.server import FastMCP

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')

mcp = FastMCP("Caption or analyze a given image based on a prompt")
md_model = None

@mcp.tool()
def process_image(prompt:str, file_path:str) -> str:
    """Describe an image based on a prompt.

       Args:
           prompt: Text prompt describing how to analyze the image
           file_path: Filepath to the image to analyze
       """

    import moondream as md
    from PIL import Image
    global md_model

    # todo check if model exists, download on demand. make model selectable.
    if md_model is None:
        # md_model = md.vl(model="./clients/Gradio/models/moondream-0_5b-int8.mf")

        # URL of the zip file
        zip_url = 'https://huggingface.co/vikhyatk/moondream2/resolve/9dddae84d54db4ac56fe37817aeaeb502ed083e2/moondream-2b-int8.mf.gz?download=true'

        # Folder to extract into
        extract_to = './models'

        # Target file to check
        target_file = os.path.join(extract_to, 'moondream-2b-int8.mf')

        # Only proceed if the target file doesn't exist
        if not os.path.exists(target_file):
            print("moondream-2b-int8.mf not found. Downloading and extracting...")
            # Make sure the extraction folder exists
            os.makedirs(extract_to, exist_ok=True)

            # Download the zip
            response = requests.get(zip_url)
            response.raise_for_status()

            # Extract it
            # Decompress and write the file
            with gzip.open(io.BytesIO(response.content), 'rb') as f_in:
                with open(target_file, 'wb') as f_out:
                    f_out.write(f_in.read())

            print(f"Done! Extracted to: {extract_to}")

        md_model = md.vl(model="./models/moondream-2b-int8.mf")

    # Load and process image
    image = Image.open(file_path)
    encoded_image = md_model.encode_image(image)

    # Generate caption
    # caption = model.caption(encoded_image)["caption"]
    # print("Caption:", caption)

    # Ask questions
    result = md_model.query(encoded_image, prompt)["answer"]
    print("Answer:", result)
    return result


```

--------------------------------------------------------------------------------
/clients/C# .Net/4.0 mcp_list_groups/Program.cs:
--------------------------------------------------------------------------------

```csharp
using System;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;

namespace MCPListGroupsClient
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 3)
            {
                Console.WriteLine("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN>");
                return;
            }

            string serverIp = GetArgument(args, "--server-ip");
            int serverPort = int.Parse(GetArgument(args, "--server-port"));
            string token = GetArgument(args, "--token");

            Console.WriteLine("📄 Abrufen der Gruppen...");

            var payload = new
            {
                command = "list_groups",
                token = token
            };

            string response = SendRequest(serverIp, serverPort, payload);

            Console.WriteLine("✔️ Antwort:");
            Console.WriteLine(response);
        }

        static string GetArgument(string[] args, string key)
        {
            int index = Array.IndexOf(args, key);
            return index >= 0 && index < args.Length - 1 ? args[index + 1] : null;
        }

        static string SendRequest(string serverIp, int serverPort, object payload)
        {
            string payloadJson = JsonConvert.SerializeObject(payload);

            try
            {
                using (TcpClient client = new TcpClient(serverIp, serverPort))
                {
                    NetworkStream stream = client.GetStream();

                    // Senden der Nutzdaten
                    byte[] data = Encoding.UTF8.GetBytes(payloadJson);
                    stream.Write(data, 0, data.Length);

                    // Empfang der Antwort
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    StringBuilder response = new StringBuilder();

                    do
                    {
                        bytesRead = stream.Read(buffer, 0, buffer.Length);
                        response.Append(Encoding.UTF8.GetString(buffer, 0, bytesRead));
                    } while (bytesRead == buffer.Length);

                    return response.ToString();
                }
            }
            catch (Exception e)
            {
                return $"Error: {e.Message}";
            }
        }
    }
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/Code Archiv/mcp_list_groups.cs:
--------------------------------------------------------------------------------

```csharp
using System;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;

namespace MCPListGroupsClient
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 3)
            {
                Console.WriteLine("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN>");
                return;
            }

            string serverIp = GetArgument(args, "--server-ip");
            int serverPort = int.Parse(GetArgument(args, "--server-port"));
            string token = GetArgument(args, "--token");

            Console.WriteLine("📄 Abrufen der Gruppen...");

            var payload = new
            {
                command = "list_groups",
                token = token
            };

            string response = SendRequest(serverIp, serverPort, payload);

            Console.WriteLine("✔️ Antwort:");
            Console.WriteLine(response);
        }

        static string GetArgument(string[] args, string key)
        {
            int index = Array.IndexOf(args, key);
            return index >= 0 && index < args.Length - 1 ? args[index + 1] : null;
        }

        static string SendRequest(string serverIp, int serverPort, object payload)
        {
            string payloadJson = JsonConvert.SerializeObject(payload);

            try
            {
                using (TcpClient client = new TcpClient(serverIp, serverPort))
                {
                    NetworkStream stream = client.GetStream();

                    // Senden der Nutzdaten
                    byte[] data = Encoding.UTF8.GetBytes(payloadJson);
                    stream.Write(data, 0, data.Length);

                    // Empfang der Antwort
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    StringBuilder response = new StringBuilder();

                    do
                    {
                        bytesRead = stream.Read(buffer, 0, buffer.Length);
                        response.Append(Encoding.UTF8.GetString(buffer, 0, bytesRead));
                    } while (bytesRead == buffer.Length);

                    return response.ToString();
                }
            }
            catch (Exception e)
            {
                return $"Error: {e.Message}";
            }
        }
    }
}

```

--------------------------------------------------------------------------------
/clients/Java/1.1 mcp_logout/MCPLogoutClient.java:
--------------------------------------------------------------------------------

```java
import org.json.JSONObject;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class MCPLogoutClient {

    public static void main(String[] args) {
        String serverIp = null;
        int serverPort = 0;
        String token = null;

        // Argumente parsen
        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "--server-ip":
                    serverIp = args[++i];
                    break;
                case "--server-port":
                    serverPort = Integer.parseInt(args[++i]);
                    break;
                case "--token":
                    token = args[++i];
                    break;
            }
        }

        // Überprüfen, ob alle Argumente angegeben wurden
        if (serverIp == null || serverPort == 0 || token == null) {
            System.out.println("❌ ERROR: Missing required parameters.");
            return;
        }

        System.out.println("🔒 Sending logout request...");
        String response = sendLogoutRequest(serverIp, serverPort, token);
        System.out.println("Response from server:");
        System.out.println(response);
    }

    private static String sendLogoutRequest(String serverIp, int serverPort, String token) {
        // JSON-Payload erstellen
        JSONObject payload = new JSONObject();
        payload.put("command", "logout");
        payload.put("token", token);

        // In String umwandeln
        String payloadJson = payload.toString();

        try (Socket client = new Socket(serverIp, serverPort)) {
            // OutputStream holen und Daten senden
            OutputStream out = client.getOutputStream();
            byte[] data = payloadJson.getBytes(StandardCharsets.UTF_8);
            out.write(data);
            out.flush();

            // Antwort empfangen
            InputStream in = client.getInputStream();
            byte[] buffer = new byte[4096];
            int bytesRead = in.read(buffer);
            if (bytesRead == -1) {
                return "❌ ERROR: No response from server.";
            }

            return new String(buffer, 0, bytesRead, StandardCharsets.UTF_8);

        } catch (IOException ex) {
            return "Error: " + ex.getMessage();
        }
    }
}

```

--------------------------------------------------------------------------------
/clients/Go/3.0 mcp_create_source/MCPCreateSourceClient.go:
--------------------------------------------------------------------------------

```go
package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
)

type CreateSourcePayload struct {
	Command   string                 `json:"command"`
	Token     string                 `json:"token"`
	Arguments map[string]interface{} `json:"arguments"`
}

func sendCreateSourceRequest(serverIP string, serverPort int, token, name, content string, groups []string) (string, error) {
	// Prepare the request payload
	payload := CreateSourcePayload{
		Command: "create_source",
		Token:   token,
		Arguments: map[string]interface{}{
			"name":    name,
			"content": content,
			"groups":  groups,
		},
	}

	// Convert the payload to JSON
	payloadJSON, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	// Create a connection to the server
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPort))
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Send the request
	_, err = conn.Write(payloadJSON)
	if err != nil {
		return "", err
	}

	// Receive the response
	var responseBuffer bytes.Buffer
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return "", err
		}
		responseBuffer.Write(buf[:n])
		if n < 4096 {
			break
		}
	}

	return responseBuffer.String(), nil
}

func main() {
	serverIP := flag.String("server-ip", "", "IP address of the MCP server")
	serverPort := flag.Int("server-port", 0, "Port number of the MCP server")
	token := flag.String("token", "", "Authentication token")
	name := flag.String("name", "", "Name of the new source")
	content := flag.String("content", "", "Content to be formatted as markdown")
	groups := flag.String("groups", "", "Comma-separated list of groups to assign the source to")

	flag.Parse()

	if *serverIP == "" || *serverPort == 0 || *token == "" || *name == "" || *content == "" {
		fmt.Println("❌ ERROR: All flags except 'groups' are required.")
		flag.Usage()
		os.Exit(1)
	}

	// Convert groups to a slice
	groupList := []string{}
	if *groups != "" {
		groupList = append(groupList, *groups)
	}

	// Send the request to create the source
	fmt.Println("📤 Sending request to create source...")
	response, err := sendCreateSourceRequest(*serverIP, *serverPort, *token, *name, *content, groupList)
	if err != nil {
		fmt.Printf("❌ ERROR: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("✔️ Response from server:")
	fmt.Println(response)
}

```

--------------------------------------------------------------------------------
/clients/Python/1.1 mcp_logout/MCPLogoutClient.py:
--------------------------------------------------------------------------------

```python
import argparse
import socket
import ssl
import json

def send_logout_request(server_ip, server_port, token, use_ssl=True, accept_self_signed=False):
    """
    Sends a logout request to the MCP server.
    """
    payload = {
        "command": "logout",
        "token": token
    }

    payload_json = json.dumps(payload)
    
    raw_socket = None
    client_socket = None

    try:
        raw_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        raw_socket.settimeout(10)

        if use_ssl:
            context = ssl.create_default_context()
            if accept_self_signed:
                context.check_hostname = False
                context.verify_mode = ssl.CERT_NONE
            client_socket = context.wrap_socket(raw_socket, server_hostname=server_ip)
        else:
            client_socket = raw_socket
        
        client_socket.connect((server_ip, server_port))
        client_socket.sendall(payload_json.encode('utf-8'))

        response = b""
        while True:
            part = client_socket.recv(4096)
            if not part:
                break
            response += part

        return response.decode('utf-8')
    except ssl.SSLError:
        return "Error: The server requires TLS encryption. Please enable SSL/TLS."
    except Exception as e:
        return f"Error: {e}"
    
    finally:
        if client_socket is not None:
            try:
                client_socket.shutdown(socket.SHUT_RDWR)
            except:
                pass
            client_socket.close()

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Send a logout request to the MCP server.")
    parser.add_argument("--server-ip", required=True, help="IP address of the MCP server")
    parser.add_argument("--server-port", type=int, required=True, help="Port number of the MCP server")
    parser.add_argument("--token", required=True, help="Authentication token")
    parser.add_argument("--use-ssl", action="store_true", help="Connect using SSL/TLS")
    parser.add_argument("--accept-self-signed", action="store_true", help="Accept self-signed certificates (disable certificate verification)")

    args = parser.parse_args()

    response = send_logout_request(
        args.server_ip,
        args.server_port,
        args.token,
        use_ssl=args.use_ssl,
        accept_self_signed=args.accept_self_signed
    )
    print("Response from server:", response)

```

--------------------------------------------------------------------------------
/agents/MCP-Client/Python/system_prompt_generator.py:
--------------------------------------------------------------------------------

```python
import json


class SystemPromptGenerator:
    """
    A class for generating system prompts dynamically based on tools JSON and user inputs.
    """

    def __init__(self):
        """
        Initialize the SystemPromptGenerator with a default system prompt template.
        """
        self.template = """
        In this environment you have access to a set of tools you can use to answer the user's question.
        {{ FORMATTING INSTRUCTIONS }}
        String and scalar parameters should be specified as is, while lists and objects should use JSON format. Note that spaces for string values are not stripped. The output is not expected to be valid XML and is parsed with regular expressions.
        Here are the functions available in JSONSchema format:
        {{ TOOL DEFINITIONS IN JSON SCHEMA }}
        {{ USER SYSTEM PROMPT }}
        {{ TOOL CONFIGURATION }}
        """
        self.default_user_system_prompt = "You are an intelligent assistant capable of using tools to solve user queries effectively."
        self.default_tool_config = "No additional configuration is required."

    def generate_prompt(
        self, tools: dict, user_system_prompt: str = None, tool_config: str = None
    ) -> str:
        """
        Generate a system prompt based on the provided tools JSON, user prompt, and tool configuration.

        Args:
            tools (dict): The tools JSON containing definitions of the available tools.
            user_system_prompt (str): A user-provided description or instruction for the assistant (optional).
            tool_config (str): Additional tool configuration information (optional).

        Returns:
            str: The dynamically generated system prompt.
        """

        # set the user system prompt
        user_system_prompt = user_system_prompt or self.default_user_system_prompt

        # set the tools config
        tool_config = tool_config or self.default_tool_config

        # get the tools schema
        tools_json_schema = json.dumps(tools, indent=2)

        # perform replacements
        prompt = self.template.replace(
            "{{ TOOL DEFINITIONS IN JSON SCHEMA }}", tools_json_schema
        )
        prompt = prompt.replace("{{ FORMATTING INSTRUCTIONS }}", "")
        prompt = prompt.replace("{{ USER SYSTEM PROMPT }}", user_system_prompt)
        prompt = prompt.replace("{{ TOOL CONFIGURATION }}", tool_config)

        # return the prompt
        return prompt

```

--------------------------------------------------------------------------------
/clients/Gradio/mcp_servers/demo-mcp-server/demo-tools-stdio.js:
--------------------------------------------------------------------------------

```javascript
import { createHTTPServer } from '@trpc/server/adapters/standalone';
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

//Import functions from tools folder
import {calculator} from "./tools/calculator.js"
import {weather} from "./tools/weather.js"
import {bitcoin, gold} from "./tools/assets.js"

//Basic config
const name = "demo-tools-stdio"
const version = "0.0.1"

const config = {
  name: name,
  version: version,
  capabilities: {
    logging: {},
  },
}

// Create an MCP server for Stdio
const server = new McpServer(config);


// Add any tool and its paramters / function by calling add_tool
await add_tool("calculator",
         "Perform basic calculations. Add, subtract, multiply, divide. Invoke this tool every time you need to perform a calculation.",
         {operation: z.enum(["add", "subtract", "multiply", "divide"]), a: z.string(), b: z.string()},
         calculator)

await add_tool("get_weather",
         "Fetch the current weather for a specific location. Invoke this tool every time you need to give information on the weather.",
        {location: z.string()},
         weather)

await add_tool("get_gold_price",
         "Get the current price of Gold. Invoke this every time the user asks for the price of Gold",
        {name: z.string()},
         gold)

await add_tool("get_bitcoin_price",
         "Get the current price of Bitcoin. Invoke this every time the user asks for the price of Bitcoin",
        {name: z.string()},
         bitcoin)

async function add_tool(name, description, schema, func){
// Add tool will add the tool to both, local and remote access systems
    server.tool(name, description, schema,
        async (args) => {
            return await func(args)
        });
}

//Connection

// Connect stdio
const transport = new StdioServerTransport();
await server.connect(transport);

//SSE
/*const app = express();

app.get("/sse", async (req, res) => {
  const transport = new SSEServerTransport("/messages", res);
  await server.connect(transport);
});

app.post("/messages", async (req, res) => {
  // Note: to support multiple simultaneous connections, these messages will
  // need to be routed to a specific matching transport. (This logic isn't
  // implemented here, for simplicity.)
  await transport.handlePostMessage(req, res);
});

app.listen(3001);*/
```

--------------------------------------------------------------------------------
/clients/C# .Net/1.0 mcp_login/Program.cs:
--------------------------------------------------------------------------------

```csharp
// Using CommandLineParser for cleaner argument parsing
using System;
using Newtonsoft.Json;

class Program
{
    static void Main(string[] args)
    {
        string serverIp = null;
        int serverPort = 0;
        string email = null;
        string password = null;

        // Loop through args and parse them manually (or use a parser library like CommandLineParser)
        for (int i = 0; i < args.Length; i++)
        {
            switch (args[i])
            {
                case "--server-ip":
                    serverIp = args[++i];
                    break;
                case "--server-port":
                    serverPort = int.Parse(args[++i]);
                    break;
                case "--email":
                    email = args[++i];
                    break;
                case "--password":
                    password = args[++i];
                    break;
            }
        }

        if (string.IsNullOrEmpty(serverIp) || serverPort == 0 || string.IsNullOrEmpty(email) || string.IsNullOrEmpty(password))
        {
            Console.WriteLine("❌ ERROR: Missing required parameters.");
            return;
        }

        Console.WriteLine("🔐 Logging in...");
        var payload = new
        {
            command = "login",
            arguments = new
            {
                email,
                password
            }
        };

        var response = SendRequest(serverIp, serverPort, payload);
        Console.WriteLine("✅ Server Response:");
        Console.WriteLine(JsonConvert.SerializeObject(response, Formatting.Indented));
    }

    static dynamic SendRequest(string serverIp, int serverPort, object payload)
    {
        using (var client = new System.Net.Sockets.TcpClient())
        {
            client.Connect(serverIp, serverPort);
            using (var stream = client.GetStream())
            {
                var payloadJson = JsonConvert.SerializeObject(payload);
                var data = System.Text.Encoding.UTF8.GetBytes(payloadJson);

                // Send payload
                stream.Write(data, 0, data.Length);

                // Receive response
                var buffer = new byte[4096];
                var bytesRead = stream.Read(buffer, 0, buffer.Length);
                var responseJson = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);

                return JsonConvert.DeserializeObject(responseJson);
            }
        }
    }
}

```

--------------------------------------------------------------------------------
/clients/C# .Net/Code Archiv/mcp_login.cs:
--------------------------------------------------------------------------------

```csharp
// Using CommandLineParser for cleaner argument parsing
using System;
using Newtonsoft.Json;

class Program
{
    static void Main(string[] args)
    {
        string serverIp = null;
        int serverPort = 0;
        string email = null;
        string password = null;

        // Loop through args and parse them manually (or use a parser library like CommandLineParser)
        for (int i = 0; i < args.Length; i++)
        {
            switch (args[i])
            {
                case "--server-ip":
                    serverIp = args[++i];
                    break;
                case "--server-port":
                    serverPort = int.Parse(args[++i]);
                    break;
                case "--email":
                    email = args[++i];
                    break;
                case "--password":
                    password = args[++i];
                    break;
            }
        }

        if (string.IsNullOrEmpty(serverIp) || serverPort == 0 || string.IsNullOrEmpty(email) || string.IsNullOrEmpty(password))
        {
            Console.WriteLine("❌ ERROR: Missing required parameters.");
            return;
        }

        Console.WriteLine("🔐 Logging in...");
        var payload = new
        {
            command = "login",
            arguments = new
            {
                email,
                password
            }
        };

        var response = SendRequest(serverIp, serverPort, payload);
        Console.WriteLine("✅ Server Response:");
        Console.WriteLine(JsonConvert.SerializeObject(response, Formatting.Indented));
    }

    static dynamic SendRequest(string serverIp, int serverPort, object payload)
    {
        using (var client = new System.Net.Sockets.TcpClient())
        {
            client.Connect(serverIp, serverPort);
            using (var stream = client.GetStream())
            {
                var payloadJson = JsonConvert.SerializeObject(payload);
                var data = System.Text.Encoding.UTF8.GetBytes(payloadJson);

                // Send payload
                stream.Write(data, 0, data.Length);

                // Receive response
                var buffer = new byte[4096];
                var bytesRead = stream.Read(buffer, 0, buffer.Length);
                var responseJson = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);

                return JsonConvert.DeserializeObject(responseJson);
            }
        }
    }
}

```
Page 4/16FirstPrevNextLast