This is page 7 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++/2.1 mcp_continue_chat/MCPChatContinuationClient.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <stdexcept>
#include <json/json.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib") // Winsock-Bibliothek verlinken
// Funktion zum Argument-Parsing
std::map<std::string, std::string> parseArguments(int argc, char* argv[]) {
std::map<std::string, std::string> args;
for (int i = 1; i < argc; ++i) {
std::string key = argv[i];
if (i + 1 < argc && key.rfind("--", 0) == 0) {
args[key] = argv[++i];
}
}
return args;
}
// Funktion zum Senden der Anfrage
std::string sendRequest(const std::string& serverIp, int serverPort, const Json::Value& payload) {
Json::StreamWriterBuilder writer;
std::string payloadJson = Json::writeString(writer, payload);
// Winsock initialisieren
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
throw std::runtime_error("Failed to initialize Winsock.");
}
// Socket erstellen
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
WSACleanup();
throw std::runtime_error("Failed to create socket.");
}
// Server-Adresse konfigurieren
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(serverPort);
if (inet_pton(AF_INET, serverIp.c_str(), &serverAddr.sin_addr) <= 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Invalid server IP address.");
}
// Verbindung herstellen
if (connect(sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Connection failed.");
}
// Daten senden
if (send(sock, payloadJson.c_str(), payloadJson.size(), 0) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Failed to send data.");
}
// Antwort empfangen
char buffer[4096];
int bytesRead;
std::ostringstream response;
do {
bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (bytesRead > 0) {
buffer[bytesRead] = '\0'; // Null-terminieren
response << buffer;
}
} while (bytesRead == sizeof(buffer) - 1);
// Socket schließen
closesocket(sock);
WSACleanup();
return response.str();
}
int main(int argc, char* argv[]) {
try {
auto args = parseArguments(argc, argv);
// Argumente extrahieren
std::string serverIp = args["--server-ip"];
int serverPort = std::stoi(args["--server-port"]);
std::string token = args["--token"];
std::string conversationId = args["--conversation-id"];
std::string message = args["--message"];
// Überprüfen, ob alle erforderlichen Parameter angegeben sind
if (serverIp.empty() || serverPort == 0 || token.empty() || conversationId.empty() || message.empty()) {
std::cerr << "Usage: MCPChatContinuationClient --server-ip <IP> --server-port <PORT> --token <TOKEN> --conversation-id <ID> --message <MESSAGE>\n";
return 1;
}
std::cout << "📤 Sending request to continue chat...\n";
// JSON-Payload erstellen
Json::Value payload;
payload["command"] = "continue_chat";
payload["token"] = token;
payload["arguments"]["chatId"] = conversationId;
payload["arguments"]["question"] = message;
// Anfrage senden und Antwort erhalten
std::string response = sendRequest(serverIp, serverPort, payload);
std::cout << "✔️ Response from server:\n" << response << "\n";
} catch (const std::exception& e) {
std::cerr << "❌ ERROR: " << e.what() << "\n";
return 1;
}
return 0;
}
```
--------------------------------------------------------------------------------
/clients/C++/4.1 mcp_store_group/MCPStoreGroupClient.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <stdexcept>
#include <json/json.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib") // Winsock-Bibliothek verlinken
// Funktion zum Argument-Parsing
std::map<std::string, std::string> parseArguments(int argc, char* argv[]) {
std::map<std::string, std::string> args;
for (int i = 1; i < argc; ++i) {
std::string key = argv[i];
if (i + 1 < argc && key.rfind("--", 0) == 0) {
args[key] = argv[++i];
}
}
return args;
}
// Funktion zum Senden der Anfrage
std::string sendRequest(const std::string& serverIp, int serverPort, const Json::Value& payload) {
Json::StreamWriterBuilder writer;
std::string payloadJson = Json::writeString(writer, payload);
// Winsock initialisieren
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
throw std::runtime_error("Failed to initialize Winsock.");
}
// Socket erstellen
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
WSACleanup();
throw std::runtime_error("Failed to create socket.");
}
// Server-Adresse konfigurieren
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(serverPort);
if (inet_pton(AF_INET, serverIp.c_str(), &serverAddr.sin_addr) <= 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Invalid server IP address.");
}
// Verbindung herstellen
if (connect(sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Connection failed.");
}
// Daten senden
if (send(sock, payloadJson.c_str(), payloadJson.size(), 0) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Failed to send data.");
}
// Antwort empfangen
char buffer[4096];
int bytesRead;
std::ostringstream response;
do {
bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (bytesRead > 0) {
buffer[bytesRead] = '\0'; // Null-terminieren
response << buffer;
}
} while (bytesRead == sizeof(buffer) - 1);
// Socket schließen
closesocket(sock);
WSACleanup();
return response.str();
}
int main(int argc, char* argv[]) {
try {
auto args = parseArguments(argc, argv);
// Argumente extrahieren
std::string serverIp = args["--server-ip"];
int serverPort = std::stoi(args["--server-port"]);
std::string groupName = args["--group-name"];
std::string token = args["--token"];
std::string description = args.count("--description") ? args["--description"] : "";
// Überprüfen, ob alle erforderlichen Parameter angegeben sind
if (serverIp.empty() || serverPort == 0 || groupName.empty() || token.empty()) {
std::cerr << "Usage: MCPStoreGroupClient --server-ip <IP> --server-port <PORT> --group-name <GROUP_NAME> --token <TOKEN> [--description <DESCRIPTION>]\n";
return 1;
}
std::cout << "📤 Sending request to store group...\n";
// JSON-Payload erstellen
Json::Value payload;
payload["command"] = "store_group";
payload["token"] = token;
payload["arguments"]["groupName"] = groupName;
payload["arguments"]["description"] = description;
// Anfrage senden und Antwort erhalten
std::string response = sendRequest(serverIp, serverPort, payload);
std::cout << "✔️ Response from server:\n" << response << "\n";
} catch (const std::exception& e) {
std::cerr << "❌ ERROR: " << e.what() << "\n";
return 1;
}
return 0;
}
```
--------------------------------------------------------------------------------
/clients/Python/4.1 mcp_store_group/MCPStoreGroupClient.py:
--------------------------------------------------------------------------------
```python
import socket
import ssl
import json
import argparse
import sys
def send_store_group_request(server_ip, server_port, group_name, token, description="", use_ssl=True, accept_self_signed=False):
"""
Sends a request to store a new group to the MCP server.
:param server_ip: IP address of the MCP server
:param server_port: Port number of the MCP server
:param group_name: Name of the group to store
:param description: Description of the group (optional)
:param token: Authentication token
:param use_ssl: Whether to use SSL/TLS for the connection
:param accept_self_signed: Whether to accept self-signed certificates
:return: Response from the server
"""
payload = {
"command": "store_group",
"token": token,
"arguments": {
"groupName": group_name,
"description": description
}
}
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: Server and/or client may require 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 request to store a new group to the MCP server.",
formatter_class=argparse.RawTextHelpFormatter
)
parser.add_argument(
"--server-ip",
required=True,
help="IP address of the MCP server\nExample: --server-ip 192.168.0.1"
)
parser.add_argument(
"--server-port",
required=True,
type=int,
help="Port number of the MCP server\nExample: --server-port 5000"
)
parser.add_argument(
"--group-name",
required=True,
help="Name of the group to store\nExample: --group-name MyGroup"
)
parser.add_argument(
"--token",
required=True,
help="Authentication token\nExample: --token YOUR_AUTH_TOKEN"
)
parser.add_argument(
"--description",
default="",
help="Description of the group (optional)\nExample: --description 'This is a test group'"
)
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)")
# If no arguments are provided, print help and exit
if len(sys.argv) == 1:
parser.print_help(sys.stderr)
sys.exit(1)
args = parser.parse_args()
response = send_store_group_request(
args.server_ip,
args.server_port,
args.group_name,
args.token,
args.description,
use_ssl=args.use_ssl,
accept_self_signed=args.accept_self_signed
)
print("Response from server:", response)
```
--------------------------------------------------------------------------------
/clients/Java/2.2 mcp_get_chat_info/MCPGetChatInfoClient.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 MCPGetChatInfoClient {
public static void main(String[] args) {
// Wir erwarten mindestens 4 Schlüssel-Werte-Paare:
// --server-ip <IP>
// --server-port <PORT>
// --token <TOKEN>
// --chat-id <CHAT_ID>
if (args.length < 8) {
printUsage();
return;
}
String serverIp = getArgument(args, "--server-ip");
String portStr = getArgument(args, "--server-port");
String token = getArgument(args, "--token");
String chatId = getArgument(args, "--chat-id");
// Falls eines der Argumente nicht vorhanden ist, Usage ausgeben
if (serverIp == null || portStr == null || token == null || chatId == null) {
printUsage();
return;
}
int serverPort = Integer.parseInt(portStr);
// JSON-Payload erstellen
JSONObject payload = new JSONObject();
payload.put("command", "get_chat_info");
payload.put("token", token);
JSONObject arguments = new JSONObject();
arguments.put("chatId", chatId);
payload.put("arguments", arguments);
System.out.println("📤 Anfrage senden...");
String response = sendRequest(serverIp, serverPort, payload);
System.out.println("✔️ Antwort:");
System.out.println(response);
}
/**
* Liest einen Wert für ein bestimmtes Argument-Schlüsselwort aus dem args-Array.
* Gibt null zurück, falls nicht gefunden oder kein Wert dahinter.
*/
private static String getArgument(String[] args, String key) {
for (int i = 0; i < args.length - 1; i++) {
if (args[i].equals(key)) {
return args[i + 1];
}
}
return null;
}
/**
* Baut eine Socket-Verbindung zum Server auf, sendet das JSON-Payload
* und empfängt die Antwort.
*/
private static String sendRequest(String serverIp, int serverPort, JSONObject payload) {
String payloadJson = payload.toString();
try (Socket client = new Socket(serverIp, serverPort)) {
// Sende das JSON
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];
StringBuilder responseBuilder = new StringBuilder();
int bytesRead;
do {
bytesRead = in.read(buffer);
if (bytesRead > 0) {
responseBuilder.append(new String(buffer, 0, bytesRead, StandardCharsets.UTF_8));
}
} while (bytesRead == buffer.length);
return responseBuilder.toString();
} catch (IOException e) {
// Analog zum C#-Code: Fehler als JSON ausgeben
JSONObject errorJson = new JSONObject();
errorJson.put("status", "error");
errorJson.put("message", e.getMessage());
return errorJson.toString();
}
}
/**
* Zeigt, wie das Programm verwendet wird.
*/
private static void printUsage() {
System.out.println("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --chat-id <CHAT_ID>");
System.out.println();
System.out.println("Beispiel:");
System.out.println(" java -cp .;json-20241224.jar MCPGetChatInfoClient \\");
System.out.println(" --server-ip 127.0.0.1 --server-port 1234 --token MyToken --chat-id 6789");
}
}
```
--------------------------------------------------------------------------------
/clients/JavaScript/2.2 mcp_get_chat_info/MCPGetChatInfoClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--chat-id':
parsedArgs.chatId = args[++i];
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer Anfrage über eine TCP-Verbindung
function sendRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
let { serverIp, serverPort, token, chatId } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind, sonst interaktiv abfragen
if (!serverIp) {
serverIp = await askQuestion('🔗 Bitte gib die Server-IP ein: ');
}
if (!serverPort) {
const portInput = await askQuestion('🔗 Bitte gib den Server-Port ein: ');
serverPort = parseInt(portInput, 10);
}
if (!token) {
token = await askQuestion('🔒 Bitte gib dein Authentifizierungstoken ein: ');
}
if (!chatId) {
chatId = await askQuestion('💬 Bitte gib die Chat-ID ein: ');
}
const payload = {
command: "get_chat_info",
token: token,
arguments: {
chatId: chatId
}
};
try {
console.log('📤 Sende Anfrage...');
const response = await sendRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/clients/Java/4.1 mcp_store_group/MCPStoreGroupClient.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 MCPStoreGroupClient {
public static void main(String[] args) {
// Minimaler Check: Wir erwarten mindestens 4 "Paare"
// (--server-ip <IP> --server-port <PORT> --group-name <NAME> --token <TOKEN>)
// plus optional: --description <TEXT>
if (args.length < 8) {
printUsage();
return;
}
String serverIp = getArgument(args, "--server-ip");
String portStr = getArgument(args, "--server-port");
String groupName = getArgument(args, "--group-name");
String token = getArgument(args, "--token");
String description= getArgument(args, "--description");
if (description == null) {
description = "";
}
// Falls eines der Argumente null ist -> Usage
if (serverIp == null || portStr == null || groupName == null || token == null) {
printUsage();
return;
}
int serverPort = Integer.parseInt(portStr);
System.out.println("📤 Sende Anfrage zur Erstellung einer Gruppe...");
// JSON-Payload
JSONObject payload = new JSONObject();
payload.put("command", "store_group");
payload.put("token", token);
// arguments
JSONObject arguments = new JSONObject();
arguments.put("groupName", groupName);
arguments.put("description", description);
payload.put("arguments", arguments);
// Server-Anfrage
String response = sendRequest(serverIp, serverPort, payload);
System.out.println("✔️ Antwort vom Server:");
System.out.println(response);
}
/**
* Sucht im args-Array nach key und gibt den Wert zurück,
* oder null, wenn key nicht gefunden wurde oder kein Wert folgt.
*/
private static String getArgument(String[] args, String key) {
for (int i = 0; i < args.length - 1; i++) {
if (args[i].equals(key)) {
return args[i + 1];
}
}
return null;
}
/**
* Stellt eine TCP-Verbindung her, sendet das JSON und empfängt die Antwort.
*/
private static String sendRequest(String serverIp, int serverPort, JSONObject payload) {
String payloadJson = payload.toString();
try (Socket client = new Socket(serverIp, serverPort)) {
// Daten senden
OutputStream out = client.getOutputStream();
byte[] data = payloadJson.getBytes(StandardCharsets.UTF_8);
out.write(data);
out.flush();
// Antwort lesen
InputStream in = client.getInputStream();
byte[] buffer = new byte[4096];
StringBuilder responseBuilder = new StringBuilder();
int bytesRead;
do {
bytesRead = in.read(buffer);
if (bytesRead > 0) {
responseBuilder.append(new String(buffer, 0, bytesRead, StandardCharsets.UTF_8));
}
} while (bytesRead == buffer.length);
return responseBuilder.toString();
} catch (IOException e) {
return "Error: " + e.getMessage();
}
}
private static void printUsage() {
System.out.println("Usage: --server-ip <IP> --server-port <PORT> --group-name <GROUP_NAME> --token <TOKEN> [--description <DESCRIPTION>]");
System.out.println();
System.out.println("Beispiel:");
System.out.println(" java -cp .;json-20241224.jar MCPStoreGroupClient \\");
System.out.println(" --server-ip 127.0.0.1 --server-port 1234 --group-name MyGroup --token MyToken --description \"Testgruppe\"");
}
}
```
--------------------------------------------------------------------------------
/clients/Java/5.2 mcp_delete_user/MCPDeleteUserClient.java:
--------------------------------------------------------------------------------
```java
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class MCPDeleteUserClient {
public static void main(String[] args) {
// Wir benötigen 4 Schlüssel (jeweils 2 Argumente): "--server-ip <IP>",
// "--server-port <PORT>", "--email <EMAIL>", "--token <TOKEN>".
// => mind. 8 Elemente in args
if (args.length < 8) {
System.out.println("Usage: --server-ip <IP> --server-port <PORT> --email <EMAIL> --token <TOKEN>");
return;
}
// Argumente auslesen
String serverIp = getArgument(args, "--server-ip");
String portStr = getArgument(args, "--server-port");
String email = getArgument(args, "--email");
String token = getArgument(args, "--token");
// Fehlende Pflichtargumente abfangen
if (serverIp == null || portStr == null || email == null || token == null) {
System.err.println("Fehler: Mindestens eines der erforderlichen Argumente ist nicht gesetzt.");
return;
}
int serverPort;
try {
serverPort = Integer.parseInt(portStr);
} catch (NumberFormatException e) {
System.err.println("Fehler: Server-Port muss eine ganze Zahl sein.");
return;
}
// JSON-Payload vorbereiten
JSONObject arguments = new JSONObject();
arguments.put("email", email);
JSONObject payload = new JSONObject();
payload.put("command", "delete_user");
payload.put("token", token);
payload.put("arguments", arguments);
System.out.println("📤 Sending delete user request...");
String response = sendRequest(serverIp, serverPort, payload.toString());
System.out.println("✔️ Response from server:");
System.out.println(response);
}
/**
* Holt den Wert eines bestimmten Arguments aus args, z.B. --server-ip 127.0.0.1
* @param args Array mit allen Argumenten
* @param key Name des gesuchten Arguments, z.B. "--server-ip"
* @return Der direkt folgende Wert oder null, wenn nicht vorhanden
*/
private static String getArgument(String[] args, String key) {
for (int i = 0; i < args.length; i++) {
if (key.equals(args[i]) && i < args.length - 1) {
return args[i + 1];
}
}
return null;
}
/**
* Stellt eine Socket-Verbindung her, sendet den JSON-String und empfängt die Server-Antwort.
*
* @param serverIp IP des Servers
* @param serverPort Port des Servers
* @param payload Zu sendender JSON-String
* @return Server-Antwort oder Fehlermeldung
*/
private static String sendRequest(String serverIp, int serverPort, String payload) {
try (Socket socket = new Socket(serverIp, serverPort)) {
// JSON an den Server senden
OutputStream output = socket.getOutputStream();
byte[] data = payload.getBytes(StandardCharsets.UTF_8);
output.write(data);
output.flush();
// Antwort vom Server lesen
BufferedReader reader = new BufferedReader(
new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)
);
StringBuilder sb = new StringBuilder();
char[] buffer = new char[4096];
int charsRead;
do {
charsRead = reader.read(buffer);
if (charsRead > 0) {
sb.append(buffer, 0, charsRead);
}
} while (charsRead == buffer.length);
return sb.toString();
} catch (Exception e) {
return "Error: " + e.getMessage();
}
}
}
```
--------------------------------------------------------------------------------
/clients/JavaScript/3.1 mcp_get_source/MCPGetSourceClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--source-id':
parsedArgs.sourceId = args[++i];
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer Get-Source-Anfrage über eine TCP-Verbindung
function sendGetSourceRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
let { serverIp, serverPort, token, sourceId } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind, sonst interaktiv abfragen
if (!serverIp) {
serverIp = await askQuestion('🔗 Bitte gib die Server-IP ein: ');
}
if (!serverPort) {
const portInput = await askQuestion('🔗 Bitte gib den Server-Port ein: ');
serverPort = parseInt(portInput, 10);
}
if (!token) {
token = await askQuestion('🔒 Bitte gib dein Authentifizierungstoken ein: ');
}
if (!sourceId) {
sourceId = await askQuestion('📁 Bitte gib die Source-ID ein: ');
}
const payload = {
command: "get_source",
token: token,
arguments: {
sourceId: sourceId
}
};
try {
console.log('📤 Sende Get-Source-Anfrage...');
const response = await sendGetSourceRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/clients/JavaScript/3.2 mcp_list_sources/MCPListSourcesClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--group-name':
parsedArgs.groupName = args[++i];
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer List-Sources-Anfrage über eine TCP-Verbindung
function sendListSourcesRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
let { serverIp, serverPort, token, groupName } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind, sonst interaktiv abfragen
if (!serverIp) {
serverIp = await askQuestion('🔗 Bitte gib die Server-IP ein: ');
}
if (!serverPort) {
const portInput = await askQuestion('🔗 Bitte gib den Server-Port ein: ');
serverPort = parseInt(portInput, 10);
}
if (!token) {
token = await askQuestion('🔒 Bitte gib dein Authentifizierungstoken ein: ');
}
if (!groupName) {
groupName = await askQuestion('👥 Bitte gib den Namen der Gruppe ein: ');
}
const payload = {
command: "list_sources",
token: token,
attributes: {
groupName: groupName
}
};
try {
console.log('📤 Sende List-Sources-Anfrage...');
const response = await sendListSourcesRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/clients/JavaScript/2.1 mcp_continue_chat/MCPContinueChatClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--conversation-id':
parsedArgs.conversationId = args[++i];
break;
case '--message':
parsedArgs.message = args[++i];
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer Continue-Chat-Anfrage über eine TCP-Verbindung
function sendContinueChatRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
const { serverIp, serverPort, token, conversationId, message } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind
if (!serverIp || !serverPort || !token || !conversationId || !message) {
console.error('❌ ERROR: Fehlende erforderliche Parameter.');
console.log('Verwendung: node MCPContinueChatClient.js --server-ip <IP> --server-port <Port> --token <Token> --conversation-id <ConversationID> --message <Nachricht>');
exit(1);
}
const payload = {
command: "continue_chat",
token: token,
arguments: {
chatId: conversationId,
question: message
}
};
try {
console.log('💬 Sende Continue-Chat-Anfrage...');
const response = await sendContinueChatRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/clients/Java/4.2 mcp_delete_group/MCPDeleteGroupClient.java:
--------------------------------------------------------------------------------
```java
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class MCPDeleteGroupClient {
public static void main(String[] args) {
// Erwartet mind. 8 Argumente:
// --server-ip <IP>
// --server-port <PORT>
// --token <TOKEN>
// --group-name <GROUP_NAME>
if (args.length < 8) {
System.out.println("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --group-name <GROUP_NAME>");
return;
}
// Argumente auslesen
String serverIp = getArgument(args, "--server-ip");
String portString = getArgument(args, "--server-port");
String token = getArgument(args, "--token");
String groupName = getArgument(args, "--group-name");
if (serverIp == null || portString == null || token == null || groupName == null) {
System.err.println("Mindestens eines der erforderlichen Argumente ist nicht gesetzt.");
return;
}
int serverPort;
try {
serverPort = Integer.parseInt(portString);
} catch (NumberFormatException e) {
System.err.println("Fehler: Server-Port muss eine ganze Zahl sein.");
return;
}
System.out.println("📤 Sending request to delete group...");
// JSON-Payload erstellen
JSONObject arguments = new JSONObject();
arguments.put("groupName", groupName);
JSONObject payload = new JSONObject();
payload.put("command", "delete_group");
payload.put("token", token);
payload.put("arguments", arguments);
// Anfrage abschicken
String response = sendRequest(serverIp, serverPort, payload.toString());
System.out.println("✔️ Response from server:");
System.out.println(response);
}
/**
* Liest den Wert zu einem bestimmten Key (z.B. "--server-ip") aus args aus
* und gibt ihn zurück.
*
* @param args Array mit allen Argumenten
* @param key Schlüssel, nach dem gesucht wird (z.B. "--server-ip")
* @return Der Wert des Arguments oder null, wenn nicht gefunden
*/
private static String getArgument(String[] args, String key) {
for (int i = 0; i < args.length; i++) {
if (args[i].equals(key) && i < args.length - 1) {
return args[i + 1];
}
}
return null;
}
/**
* Erstellt eine Socket-Verbindung, sendet den JSON-Payload und empfängt die
* Antwort als String.
*
* @param serverIp IP-Adresse des Servers
* @param serverPort Port des Servers
* @param payload Zu sendender JSON-String
* @return Antwort vom Server oder Fehlermeldung bei Exception
*/
private static String sendRequest(String serverIp, int serverPort, String payload) {
try (Socket socket = new Socket(serverIp, serverPort)) {
// Payload an den Server senden
OutputStream output = socket.getOutputStream();
byte[] data = payload.getBytes(StandardCharsets.UTF_8);
output.write(data);
output.flush();
// Antwort lesen
BufferedReader reader = new BufferedReader(
new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)
);
StringBuilder sb = new StringBuilder();
char[] buffer = new char[4096];
int charsRead;
do {
charsRead = reader.read(buffer);
if (charsRead > 0) {
sb.append(buffer, 0, charsRead);
}
} while (charsRead == buffer.length);
return sb.toString();
} catch (Exception e) {
return "Error: " + e.getMessage();
}
}
}
```
--------------------------------------------------------------------------------
/agents/SourceManagerAgent/Python/local_db.py:
--------------------------------------------------------------------------------
```python
# DATABASE LOGIC
import json
import os
import shutil
import sqlite3
from dataclasses import dataclass
from logging import Filter
from sqlite3 import Error
@dataclass
class Document:
id: str
content: int
groups: str
file: str
user: str
def create_sql_table(db):
try:
import os
if not os.path.exists(r'db'):
os.makedirs(r'db')
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute(""" CREATE TABLE IF NOT EXISTS users (
id text PRIMARY KEY,
content integer NOT NULL,
groups text,
file text,
user text
); """)
cur.execute("SELECT name FROM sqlite_master")
con.close()
except Error as e:
print(e)
def add_to_sql_table(db, id, content, groups, file, user):
try:
con = sqlite3.connect(db)
cur = con.cursor()
# we only store the beginning of the text in the database, for a user to see what happened.
data = (id, content[:256], groups, file, user)
cur.execute("INSERT or IGNORE INTO users VALUES(?, ?, ?, ?, ?)", data)
con.commit()
con.close()
except Error as e:
print("Error when Adding to DB: " + str(e))
def update_sql_table(db, id, content, groups, file, user):
try:
con = sqlite3.connect(db)
cur = con.cursor()
data = (content, groups, file, user, id)
cur.execute(""" UPDATE users
SET content = ? ,
groups = ? ,
file = ? ,
user = ? ,
WHERE id = ?""", data)
con.commit()
con.close()
except Error as e:
print("Error Updating DB: " + str(e))
def get_from_sql_table(db, id):
try:
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute("SELECT * FROM users WHERE id=?", (id,))
row = cur.fetchone()
con.close()
if row is None:
return None
else:
document = Document
document.id = row[0]
document.content = row[1]
document.groups = row[2]
document.file = row[3]
document.user = row[4]
return document
except Error as e:
print("Error Getting from DB: " + str(e))
def delete_from_sql_table(db, id):
try:
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute("DELETE FROM users WHERE id=?", (id,))
con.commit()
con.close()
except Error as e:
print(e)
def clean_db(db):
try:
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute("SELECT * FROM users WHERE id IS NULL OR id = '' ")
rows = cur.fetchall()
for row in rows:
print(row)
delete_from_sql_table(db, row[0])
con.close()
return rows
except Error as e:
print(e)
def list_db(db):
try:
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute("SELECT * FROM users ORDER BY id DESC")
rows = cur.fetchall()
for row in rows:
print(row)
con.close()
except Error as e:
print(e)
def get_all_db_entries(db):
results = []
try:
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute("SELECT * FROM users ORDER BY id DESC")
rows = cur.fetchall()
for row in rows:
document = Document
document.id = row[0]
document.content = row[1]
document.groups = row[2]
document.file = row[3]
document.user = row[4]
results.append(document)
con.close()
return results
except Error as e:
print(e)
return []
```
--------------------------------------------------------------------------------
/clients/Python/1.0 mcp_login/MCPLoginClient.py:
--------------------------------------------------------------------------------
```python
#!/usr/bin/env python3
import socket
import ssl
import json
import argparse
def send_request(server_ip, server_port, payload, use_ssl=True, accept_self_signed=False):
"""
Sends a generic request to the server.
If use_ssl is True, an SSL/TLS connection will be established.
If accept_self_signed is True, self-signed certificates will be accepted.
"""
payload_json = json.dumps(payload)
# Initialize variables here so they are visible in the finally block
raw_socket = None
client_socket = None
try:
# Create a raw socket
raw_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
raw_socket.settimeout(10)
# Establish SSL/TLS connection if requested
if use_ssl:
context = ssl.create_default_context()
if accept_self_signed:
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
# Wrap socket in SSL context
client_socket = context.wrap_socket(raw_socket, server_hostname=server_ip)
else:
# Unencrypted connection
client_socket = raw_socket
# Connect to the server
client_socket.connect((server_ip, server_port))
# Send request (with newline as delimiter)
client_socket.sendall((payload_json + "\n").encode("utf-8"))
# Receive response; stop after first line or if recv() returns empty
response = b""
while True:
part = client_socket.recv(4096)
if not part:
# Server closed connection or no more data received
break
response += part
# Stop if a newline is detected
if b'\n' in part:
break
# Return response as JSON
return json.loads(response.decode("utf-8").strip())
except ssl.SSLError:
return {"status": "error", "message": "Connection failed: server and client may require TLS encryption. Please enable SSL/TLS."}
except Exception as e:
return {"status": "error", "message": str(e)}
finally:
# Ensure the connection is closed properly
if client_socket is not None:
try:
# Shutdown signals that no further data will be sent/received
client_socket.shutdown(socket.SHUT_RDWR)
except:
pass # Ignore error if already closed
client_socket.close()
def login(server_ip, server_port, email, password, use_ssl=True, accept_self_signed=False):
"""
Performs login and returns the full response.
"""
payload = {
"command": "login",
"arguments": {
"email": email,
"password": password
}
}
response = send_request(server_ip, server_port, payload, use_ssl, accept_self_signed)
return response
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Login to the MCP server and receive a token.")
parser.add_argument("--server-ip", required=True, help="IP address of the MCP server")
parser.add_argument("--server-port", required=True, type=int, help="Port number of the MCP server")
parser.add_argument("--email", required=True, help="Email address for login")
parser.add_argument("--password", required=True, help="Password for login")
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()
try:
print("🔐 Logging in...")
response = login(
args.server_ip,
args.server_port,
args.email,
args.password,
use_ssl=args.use_ssl,
accept_self_signed=args.accept_self_signed
)
print("✅ Server Response:")
print(json.dumps(response, indent=4))
except Exception as e:
print("❌ ERROR:", e)
```
--------------------------------------------------------------------------------
/clients/JavaScript/4.0 mcp_list_groups/MCPListGroupsClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer generischen Anfrage über eine TCP-Verbindung
function sendRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
const TIMEOUT_DURATION = 10000; // 10 Sekunden
// Setze einen Timeout
const timeout = setTimeout(() => {
client.destroy(); // Zerstöre die Verbindung
reject(new Error('Verbindungs-Timeout: Der Server hat nicht rechtzeitig geantwortet.'));
}, TIMEOUT_DURATION);
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
clearTimeout(timeout); // Entferne den Timeout
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
clearTimeout(timeout); // Entferne den Timeout
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
clearTimeout(timeout); // Entferne den Timeout
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
let { serverIp, serverPort, token } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind, sonst interaktiv abfragen
if (!serverIp) {
serverIp = await askQuestion('🔗 Bitte gib die Server-IP ein: ');
}
if (!serverPort) {
const portInput = await askQuestion('🔗 Bitte gib den Server-Port ein: ');
serverPort = parseInt(portInput, 10);
}
if (!token) {
token = await askQuestion('🔒 Bitte gib dein Authentifizierungstoken ein: ');
}
const payload = {
command: "list_groups",
token: token
};
try {
console.log('📄 Abrufen der Gruppen...');
const response = await sendRequest(serverIp, serverPort, payload);
console.log('✔️ Antwort:', JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/clients/Java/2.1 mcp_continue_chat/MCPContinueChatClient.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;
import java.util.Arrays;
public class MCPContinueChatClient {
public static void main(String[] args) {
// Minimalprüfung, ob genug Argumente vorhanden sind.
// (Die genaue Prüfung folgt unten, falls einzelne Argumente fehlen.)
if (args.length < 6) {
printUsage();
return;
}
String serverIp = getArgument(args, "--server-ip");
String serverPortStr = getArgument(args, "--server-port");
String token = getArgument(args, "--token");
String conversationId = getArgument(args, "--conversation-id");
String message = getArgument(args, "--message");
// Ggf. fehlende Argumente prüfen
if (serverIp == null || serverPortStr == null || token == null
|| conversationId == null || message == null) {
printUsage();
return;
}
int serverPort = Integer.parseInt(serverPortStr);
// JSON-Payload erstellen
JSONObject payload = new JSONObject();
payload.put("command", "continue_chat");
payload.put("token", token);
JSONObject arguments = new JSONObject();
arguments.put("chatId", conversationId);
arguments.put("question", message);
payload.put("arguments", arguments);
System.out.println("📤 Sending request to continue chat...");
String response = sendRequest(serverIp, serverPort, payload);
System.out.println("✔️ Response from server:");
System.out.println(response);
}
/**
* Hilfsmethode, um ein bestimmtes Argument aus dem args-Array auszulesen.
*/
private static String getArgument(String[] args, String key) {
for (int i = 0; i < args.length - 1; i++) {
if (args[i].equals(key)) {
return args[i + 1];
}
}
return null;
}
/**
* Sendet das JSON-Payload an den MCP-Server und empfängt die Antwort.
*/
private static String sendRequest(String serverIp, int serverPort, JSONObject payload) {
String payloadJson = payload.toString();
try (Socket client = new Socket(serverIp, serverPort)) {
// Sende das Payload
OutputStream out = client.getOutputStream();
byte[] data = payloadJson.getBytes(StandardCharsets.UTF_8);
out.write(data);
out.flush();
// Empfang der Antwort
InputStream in = client.getInputStream();
byte[] buffer = new byte[4096];
StringBuilder responseBuilder = new StringBuilder();
int bytesRead;
do {
bytesRead = in.read(buffer);
if (bytesRead > 0) {
responseBuilder.append(new String(buffer, 0, bytesRead, StandardCharsets.UTF_8));
}
} while (bytesRead == buffer.length);
return responseBuilder.toString();
} catch (IOException e) {
// Im Fehlerfall geben wir ein JSON mit "status" = "error" zurück,
// analog zum C#-Beispiel mit JsonConvert.
JSONObject errorJson = new JSONObject();
errorJson.put("status", "error");
errorJson.put("message", e.getMessage());
return errorJson.toString();
}
}
private static void printUsage() {
System.out.println("Usage: ");
System.out.println(" --server-ip <IP> --server-port <PORT> --token <TOKEN>");
System.out.println(" --conversation-id <ID> --message <MESSAGE>");
System.out.println();
System.out.println("Beispiel:");
System.out.println(" java -cp .;json-20241224.jar MCPContinueChatClient \\");
System.out.println(" --server-ip 127.0.0.1 --server-port 1234 --token MyToken \\");
System.out.println(" --conversation-id xyz123 --message \"Gibt es ein Update?\"");
}
}
```
--------------------------------------------------------------------------------
/clients/C++/1.0 mcp_login/Non-TLS version/MCPLoginClient.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <string>
#include <map>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <stdexcept>
#include <json/json.h>
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif
// Function to parse command-line arguments
std::map<std::string, std::string> parseArguments(int argc, char* argv[]) {
std::map<std::string, std::string> args;
for (int i = 1; i < argc; i++) {
std::string key = argv[i];
if (i + 1 < argc) {
args[key] = argv[++i];
}
}
return args;
}
// Function to send the payload to the server and receive a response
std::string sendRequest(const std::string& serverIp, int serverPort, const Json::Value& payload) {
#ifdef _WIN32
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
throw std::runtime_error("Failed to initialize Winsock");
}
#endif
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
#ifdef _WIN32
WSACleanup();
#endif
throw std::runtime_error("Failed to create socket");
}
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(serverPort);
if (inet_pton(AF_INET, serverIp.c_str(), &serverAddr.sin_addr) <= 0) {
#ifdef _WIN32
closesocket(sock);
WSACleanup();
#else
close(sock);
#endif
throw std::runtime_error("Invalid server IP address");
}
if (connect(sock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
#ifdef _WIN32
closesocket(sock);
WSACleanup();
#else
close(sock);
#endif
throw std::runtime_error("Connection failed");
}
// Serialize the JSON payload to a string
Json::StreamWriterBuilder writer;
std::string payloadJson = Json::writeString(writer, payload);
// Send the payload
if (send(sock, payloadJson.c_str(), payloadJson.size(), 0) < 0) {
#ifdef _WIN32
closesocket(sock);
WSACleanup();
#else
close(sock);
#endif
throw std::runtime_error("Failed to send data");
}
// Receive the response
char buffer[4096];
ssize_t bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (bytesRead < 0) {
#ifdef _WIN32
closesocket(sock);
WSACleanup();
#else
close(sock);
#endif
throw std::runtime_error("Failed to receive data");
}
buffer[bytesRead] = '\0'; // Null-terminate the received data
#ifdef _WIN32
closesocket(sock);
WSACleanup();
#else
close(sock);
#endif
return std::string(buffer);
}
int main(int argc, char* argv[]) {
try {
auto args = parseArguments(argc, argv);
// Extract required parameters
std::string serverIp = args["--server-ip"];
int serverPort = std::stoi(args["--server-port"]);
std::string email = args["--email"];
std::string password = args["--password"];
if (serverIp.empty() || serverPort == 0 || email.empty() || password.empty()) {
std::cerr << "❌ ERROR: Missing required parameters.\n";
return 1;
}
std::cout << "🔐 Logging in...\n";
// Build the payload
Json::Value payload;
payload["command"] = "login";
payload["arguments"]["email"] = email;
payload["arguments"]["password"] = password;
// Send request and get response
std::string responseJson = sendRequest(serverIp, serverPort, payload);
// Parse and print the server response
Json::CharReaderBuilder reader;
Json::Value response;
std::istringstream responseStream(responseJson);
std::string errs;
if (!Json::parseFromStream(reader, responseStream, &response, &errs)) {
throw std::runtime_error("Failed to parse server response: " + errs);
}
std::cout << "✅ Server Response:\n" << response.toStyledString();
} catch (const std::exception& e) {
std::cerr << "❌ ERROR: " << e.what() << '\n';
return 1;
}
return 0;
}
```
--------------------------------------------------------------------------------
/clients/Python/3.3 mcp_edit_source/MCPEditSourceClient.py:
--------------------------------------------------------------------------------
```python
import socket
import ssl
import json
import argparse
def send_edit_source_request(server_ip, server_port, token, source_id, title=None, content=None, groups=None, use_ssl=True, accept_self_signed=False):
"""
Sends a request to edit an existing source to the MCP server.
:param server_ip: IP address of the MCP server
:param server_port: Port number of the MCP server
:param token: Authentication token
:param source_id: ID of the source to edit
:param title: New title for the source (optional)
:param content: Updated content in markdown format (optional)
:param groups: List of updated groups (optional)
:param use_ssl: Whether to use SSL/TLS for the connection
:param accept_self_signed: Whether to accept self-signed certificates
:return: Response from the server
"""
payload = {
"command": "edit_source",
"token": token,
"arguments": {
"sourceId": source_id,
"title": title, # Title is used instead of name
"content": content,
"groups": groups or [] # Empty array if no groups are provided
}
}
# Remove None values from the payload
payload["arguments"] = {k: v for k, v in payload["arguments"].items() if v is not None}
# Convert the payload to a JSON string
payload_json = json.dumps(payload)
raw_socket = None
client_socket = None
try:
# Create a socket object
raw_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
raw_socket.settimeout(10)
# Establish SSL/TLS connection if required
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
# Connect to the server
client_socket.connect((server_ip, server_port))
# Send the request
client_socket.sendall(payload_json.encode('utf-8'))
# Receive the response
response = b""
while True:
part = client_socket.recv(4096)
if not part:
break
response += part
# Decode the response
return response.decode('utf-8')
except ssl.SSLError:
return "Error: Server and/or client may require 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 request to edit an existing source to the MCP server.")
parser.add_argument("--server-ip", required=True, help="IP address of the MCP server")
parser.add_argument("--server-port", required=True, type=int, help="Port number of the MCP server")
parser.add_argument("--token", required=True, help="Authentication token")
parser.add_argument("--source-id", required=True, help="ID of the source to edit")
parser.add_argument("--title", help="New title for the source (optional)")
parser.add_argument("--content", help="Updated content in markdown format (optional)")
parser.add_argument("--groups", nargs='*', default=[], help="List of updated groups (optional)")
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_edit_source_request(
args.server_ip,
args.server_port,
args.token,
args.source_id,
args.title,
args.content,
args.groups,
use_ssl=args.use_ssl,
accept_self_signed=args.accept_self_signed
)
print("Response from server:", response)
```
--------------------------------------------------------------------------------
/clients/C# .Net/5.0 mcp_store_user/Program.cs:
--------------------------------------------------------------------------------
```csharp
using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;
namespace MCPStoreUserClient
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 14)
{
Console.WriteLine("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --name <NAME> --email <EMAIL> --password <PASSWORD> [--language <LANG>] [--timezone <TIMEZONE>] [--roles <ROLE1 ROLE2>] [--groups <GROUP1 GROUP2>] [--usePublic] [--activateFtp] [--ftpPassword <FTP_PASSWORD>]");
return;
}
string serverIp = GetArgument(args, "--server-ip");
int serverPort = int.Parse(GetArgument(args, "--server-port"));
string token = GetArgument(args, "--token");
string name = GetArgument(args, "--name");
string email = GetArgument(args, "--email");
string password = GetArgument(args, "--password");
string language = GetArgument(args, "--language") ?? "en";
string timezone = GetArgument(args, "--timezone") ?? "Europe/Berlin";
List<string> roles = GetListArgument(args, "--roles");
List<string> groups = GetListArgument(args, "--groups");
bool usePublic = Array.Exists(args, arg => arg == "--usePublic");
bool activateFtp = Array.Exists(args, arg => arg == "--activateFtp");
string ftpPassword = GetArgument(args, "--ftpPassword") ?? "";
var payload = new
{
command = "store_user",
token = token,
arguments = new
{
name = name,
email = email,
password = password,
language = language,
timezone = timezone,
roles = roles,
groups = groups,
usePublic = usePublic,
activateFtp = activateFtp,
ftpPassword = ftpPassword
}
};
Console.WriteLine("📤 Sending store user request...");
string response = SendRequest(serverIp, serverPort, payload);
Console.WriteLine("✔️ Response from server:");
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 List<string> GetListArgument(string[] args, string key)
{
int index = Array.IndexOf(args, key);
List<string> values = new List<string>();
if (index >= 0)
{
for (int i = index + 1; i < args.Length && !args[i].StartsWith("--"); i++)
{
values.Add(args[i]);
}
}
return values;
}
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();
// Send payload
byte[] data = Encoding.UTF8.GetBytes(payloadJson);
stream.Write(data, 0, data.Length);
// Receive response
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_store_user.cs:
--------------------------------------------------------------------------------
```csharp
using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;
namespace MCPStoreUserClient
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 14)
{
Console.WriteLine("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --name <NAME> --email <EMAIL> --password <PASSWORD> [--language <LANG>] [--timezone <TIMEZONE>] [--roles <ROLE1 ROLE2>] [--groups <GROUP1 GROUP2>] [--usePublic] [--activateFtp] [--ftpPassword <FTP_PASSWORD>]");
return;
}
string serverIp = GetArgument(args, "--server-ip");
int serverPort = int.Parse(GetArgument(args, "--server-port"));
string token = GetArgument(args, "--token");
string name = GetArgument(args, "--name");
string email = GetArgument(args, "--email");
string password = GetArgument(args, "--password");
string language = GetArgument(args, "--language") ?? "en";
string timezone = GetArgument(args, "--timezone") ?? "Europe/Berlin";
List<string> roles = GetListArgument(args, "--roles");
List<string> groups = GetListArgument(args, "--groups");
bool usePublic = Array.Exists(args, arg => arg == "--usePublic");
bool activateFtp = Array.Exists(args, arg => arg == "--activateFtp");
string ftpPassword = GetArgument(args, "--ftpPassword") ?? "";
var payload = new
{
command = "store_user",
token = token,
arguments = new
{
name = name,
email = email,
password = password,
language = language,
timezone = timezone,
roles = roles,
groups = groups,
usePublic = usePublic,
activateFtp = activateFtp,
ftpPassword = ftpPassword
}
};
Console.WriteLine("📤 Sending store user request...");
string response = SendRequest(serverIp, serverPort, payload);
Console.WriteLine("✔️ Response from server:");
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 List<string> GetListArgument(string[] args, string key)
{
int index = Array.IndexOf(args, key);
List<string> values = new List<string>();
if (index >= 0)
{
for (int i = index + 1; i < args.Length && !args[i].StartsWith("--"); i++)
{
values.Add(args[i]);
}
}
return values;
}
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();
// Send payload
byte[] data = Encoding.UTF8.GetBytes(payloadJson);
stream.Write(data, 0, data.Length);
// Receive response
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/Python/5.0 mcp_store_user/MCPStoreUserClient.py:
--------------------------------------------------------------------------------
```python
import socket
import ssl
import json
import argparse
import sys
def send_store_user_request(server_ip, server_port, token, name, email, password, language, timezone, roles, groups, usePublic, activateFtp, ftpPassword, use_ssl=True, accept_self_signed=False):
"""
Sends a request to create a new user on the MCP server.
"""
payload = {
"command": "store_user",
"token": token,
"arguments": {
"name": name,
"email": email,
"password": password,
"language": language,
"timezone": timezone,
"roles": roles,
"groups": groups,
"usePublic": usePublic,
"activateFtp": activateFtp,
"ftpPassword": ftpPassword
}
}
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: Server and/or client may require 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 request to create a new user on the MCP server.",
formatter_class=argparse.RawTextHelpFormatter
)
parser.add_argument("--server-ip", required=True, help="IP address of the MCP server")
parser.add_argument("--server-port", required=True, type=int, help="Port number of the MCP server")
parser.add_argument("--token", required=True, help="Authentication token")
parser.add_argument("--name", required=True, help="Name of the user")
parser.add_argument("--email", required=True, help="Email of the user")
parser.add_argument("--password", required=True, help="Password for the user")
parser.add_argument("--language", default="en", help="Language code (optional)")
parser.add_argument("--timezone", default="Europe/Berlin", help="Timezone (optional)")
parser.add_argument("--roles", nargs="+", default=[], help="Roles for the user (optional)")
parser.add_argument("--groups", nargs="+", default=[], help="Groups for the user (optional)")
parser.add_argument("--usePublic", action="store_true", help="Use the public knowledge base")
parser.add_argument("--activateFtp", action="store_true", help="Activate FTP for the user")
parser.add_argument("--ftpPassword", default="", help="FTP password for the user (optional)")
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)")
if len(sys.argv) == 1:
parser.print_help(sys.stderr)
sys.exit(1)
args = parser.parse_args()
response = send_store_user_request(
args.server_ip,
args.server_port,
args.token,
args.name,
args.email,
args.password,
args.language,
args.timezone,
args.roles,
args.groups,
args.usePublic,
args.activateFtp,
args.ftpPassword,
use_ssl=args.use_ssl,
accept_self_signed=args.accept_self_signed
)
print("Response from server:", response)
```
--------------------------------------------------------------------------------
/agents/MCP-Client/Python/llm_client.py:
--------------------------------------------------------------------------------
```python
import logging
import os
import uuid
from typing import Any, Dict, List
import httpx
from dotenv import load_dotenv
from openai import OpenAI
# Load environment variables
load_dotenv()
class LLMClient:
def __init__(self, provider="pgpt", model="pgpt-mistral-nemo-12b", api_key=None):
# set the provider, model and api key
self.provider = provider
self.model = model
def create_completion(
self, messages: List[Dict], tools: List = None
) -> Dict[str, Any]:
"""Create a chat completion using the specified LLM provider."""
if self.provider == "pgpt":
return self._pgpt_completion(messages, tools)
else:
# unsupported providers
raise ValueError(f"Unsupported provider: {self.provider}")
def _pgpt_completion(self, messages: List[Dict], tools: List) -> Dict[str, Any]:
vllm = os.getenv("USE_VLLM", "False")
try:
if vllm == "True":
base_url = os.getenv("PGPT_OAI_BASE_URL_VLLM")
if not base_url:
raise ValueError("The PGPT_OAI_BASE_URL_VLLM environment variable is not set.")
api_key = os.getenv("PGPT_API_KEY_VLLM")
if not api_key:
raise ValueError("The PGPT_API_KEY_VLLM environment variable is not set.")
http_client = httpx.Client(verify=False, http2=True)
client = OpenAI(
base_url=base_url,
api_key=api_key,
http_client=http_client
)
logging.info(f"Amount of messages: {len(messages)}")
response = client.chat.completions.create(
model="/models/mistral-nemo-12b",
temperature=0.8,
top_p=0.8,
messages=messages,
tools = tools or None,
stream = False
)
else:
newSession = False
if len(messages) % 2: # system prompt and user prompt
newSession = True
base_url = os.getenv("PGPT_OAI_BASE_URL")
if not base_url:
raise ValueError("The PGPT_OAI_BASE_URL environment variable is not set.")
api_key = os.getenv("PGPT_API_KEY")
if not api_key:
raise ValueError("The PGPT_API_KEY environment variable is not set.")
client = OpenAI(
api_key=api_key,
base_url=base_url # change the default port if needed
)
response = client.chat.completions.create(
model="pgpt-mistral-nemo-12b",
messages=messages,
tools=tools or None,
extra_body={
"groups": [],
"newSession": newSession
},
stream = False)
logging.info(f"PGPT raw response: {response}")
# Extract the message and tool calls
try:
message = response.choices[0].message
except:
message = response
tool_calls = []
# Convert Ollama tool calls to OpenAI format
if hasattr(message, "tool_calls") and message.tool_calls:
for tool in message.tool_calls:
tool_calls.append(
{
"id": str(uuid.uuid4()), # Generate unique ID
"type": "function",
"function": {
"name": tool.function.name,
"arguments": tool.function.arguments,
},
}
)
return {
"response": message.content if message else "No response",
"tool_calls": tool_calls,
}
except Exception as e:
# error
logging.error(f"PGPT API Error: {str(e)}")
raise ValueError(f"PGPT API Error: {str(e)}")
```
--------------------------------------------------------------------------------
/clients/C++/3.0 mcp_create_source/MCPCreateSourceClient.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <sstream>
#include <stdexcept>
#include <json/json.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib") // Winsock-Bibliothek verlinken
// Funktion zum Argument-Parsing
std::map<std::string, std::string> parseArguments(int argc, char* argv[], std::vector<std::string>& groups) {
std::map<std::string, std::string> args;
for (int i = 1; i < argc; ++i) {
std::string key = argv[i];
if (i + 1 < argc && key.rfind("--", 0) == 0) {
if (key == "--groups") {
while (++i < argc && argv[i][0] != '-') {
groups.push_back(argv[i]);
}
--i; // Schritt zurücksetzen, um nicht zu überspringen
} else {
args[key] = argv[++i];
}
}
}
return args;
}
// Funktion zum Senden der Anfrage
std::string sendRequest(const std::string& serverIp, int serverPort, const Json::Value& payload) {
Json::StreamWriterBuilder writer;
std::string payloadJson = Json::writeString(writer, payload);
// Winsock initialisieren
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
throw std::runtime_error("Failed to initialize Winsock.");
}
// Socket erstellen
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
WSACleanup();
throw std::runtime_error("Failed to create socket.");
}
// Server-Adresse konfigurieren
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(serverPort);
if (inet_pton(AF_INET, serverIp.c_str(), &serverAddr.sin_addr) <= 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Invalid server IP address.");
}
// Verbindung herstellen
if (connect(sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Connection failed.");
}
// Daten senden
if (send(sock, payloadJson.c_str(), payloadJson.size(), 0) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Failed to send data.");
}
// Antwort empfangen
char buffer[4096];
int bytesRead;
std::ostringstream response;
do {
bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (bytesRead > 0) {
buffer[bytesRead] = '\0'; // Null-terminieren
response << buffer;
}
} while (bytesRead == sizeof(buffer) - 1);
// Socket schließen
closesocket(sock);
WSACleanup();
return response.str();
}
int main(int argc, char* argv[]) {
try {
std::vector<std::string> groups;
auto args = parseArguments(argc, argv, groups);
// Argumente extrahieren
std::string serverIp = args["--server-ip"];
int serverPort = std::stoi(args["--server-port"]);
std::string token = args["--token"];
std::string name = args["--name"];
std::string content = args["--content"];
// Überprüfen, ob alle erforderlichen Parameter angegeben sind
if (serverIp.empty() || serverPort == 0 || token.empty() || name.empty() || content.empty()) {
std::cerr << "Usage: MCPCreateSourceClient --server-ip <IP> --server-port <PORT> --token <TOKEN> --name <NAME> --content <CONTENT> [--groups <GROUP1 GROUP2 ...>]\n";
return 1;
}
std::cout << "📤 Sending request to create a new source...\n";
// JSON-Payload erstellen
Json::Value payload;
payload["command"] = "create_source";
payload["token"] = token;
payload["arguments"]["name"] = name;
payload["arguments"]["content"] = content;
Json::Value groupsJson(Json::arrayValue);
for (const auto& group : groups) {
groupsJson.append(group);
}
payload["arguments"]["groups"] = groupsJson;
// Anfrage senden und Antwort erhalten
std::string response = sendRequest(serverIp, serverPort, payload);
std::cout << "✔️ Response from server:\n" << response << "\n";
} catch (const std::exception& e) {
std::cerr << "❌ ERROR: " << e.what() << "\n";
return 1;
}
return 0;
}
```
--------------------------------------------------------------------------------
/clients/Python/2.0 mcp_chat/MCPChatClient.py:
--------------------------------------------------------------------------------
```python
import socket
import ssl
import json
import argparse
import sys
sys.stdout.reconfigure(encoding='utf-8')
sys.stdin.reconfigure(encoding='utf-8')
def send_mcp_request(server_ip, server_port, token, question, use_public, groups=None, language="de", use_ssl=True, accept_self_signed=False):
"""
Sends a question to an MCP server and retrieves the response.
:param server_ip: IP address of the MCP server
:param server_port: Port number of the MCP server
:param token: Authentication token for the MCP server
:param question: The question to send
:param use_public: Whether to use the public knowledge base
:param groups: List of groups for retrieval-augmented generation
:param language: Language code for the request
:param use_ssl: Whether to use SSL/TLS for the connection
:param accept_self_signed: Whether to accept self-signed certificates
:return: Response from the server
"""
# Prepare the request payload
payload = {
"command": "chat",
"token": token,
"arguments": {
"question": question,
"usePublic": use_public,
"groups": groups or [],
"language": language
}
}
# Convert the payload to a JSON string
payload_json = json.dumps(payload)
# Initialize socket variables
raw_socket = None
client_socket = None
try:
# Create a socket object
raw_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
raw_socket.settimeout(10)
# Establish SSL/TLS connection if required
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
# Connect to the server
client_socket.connect((server_ip, server_port))
# Send the request
client_socket.sendall(payload_json.encode('utf-8'))
# Receive the response
response = b""
while True:
part = client_socket.recv(4096)
if not part:
break
response += part
# Decode the response
return json.loads(response.decode('utf-8'))
except ssl.SSLError:
return {"status": "error", "message": "Connection failed: Server and/or Client may require TLS encryption. Please enable SSL/TLS."}
except Exception as e:
return {"status": "error", "message": str(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 question to the MCP server and retrieve the response.")
parser.add_argument("--server-ip", required=True, help="IP address of the MCP server")
parser.add_argument("--server-port", required=True, type=int, help="Port number of the MCP server")
parser.add_argument("--token", required=True, help="Authentication token")
parser.add_argument("--question", required=True, help="The question to ask the MCP server")
parser.add_argument("--use-public", action="store_true", help="Use the public knowledge base")
parser.add_argument("--groups", nargs="*", help="List of groups for retrieval-augmented generation", default=[])
parser.add_argument("--language", default="de", help="Language code for the request (default: 'de')")
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()
# Send the question to the MCP server
response = send_mcp_request(
server_ip=args.server_ip,
server_port=args.server_port,
token=args.token,
question=args.question,
use_public=args.use_public,
groups=args.groups,
language=args.language,
use_ssl=args.use_ssl,
accept_self_signed=args.accept_self_signed
)
print("Response from server:", json.dumps(response, indent=2, ensure_ascii=False))
```
--------------------------------------------------------------------------------
/clients/C# .Net/5.1 mcp_edit_user/Program.cs:
--------------------------------------------------------------------------------
```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;
namespace MCPEditUserClient
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 4)
{
Console.WriteLine("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --user-id <USER_ID> [optional parameters]");
return;
}
string serverIp = GetArgument(args, "--server-ip");
int serverPort = int.Parse(GetArgument(args, "--server-port"));
string token = GetArgument(args, "--token");
string userId = GetArgument(args, "--user-id");
string name = GetArgument(args, "--name");
string email = GetArgument(args, "--email");
string password = GetArgument(args, "--password");
string language = GetArgument(args, "--language");
string timezone = GetArgument(args, "--timezone");
List<string> roles = GetListArgument(args, "--roles");
List<string> groups = GetListArgument(args, "--groups");
bool usePublic = Array.Exists(args, arg => arg == "--usePublic");
bool activateFtp = Array.Exists(args, arg => arg == "--activateFtp");
string ftpPassword = GetArgument(args, "--ftpPassword");
var arguments = new Dictionary<string, object>
{
{ "userId", userId },
{ "name", name },
{ "email", email },
{ "password", password },
{ "language", language },
{ "timezone", timezone },
{ "roles", roles },
{ "groups", groups },
{ "usePublic", usePublic },
{ "activateFtp", activateFtp },
{ "ftpPassword", ftpPassword }
};
// Remove null or empty values from arguments
arguments = arguments.Where(kv => kv.Value != null && !(kv.Value is string str && string.IsNullOrWhiteSpace(str))).ToDictionary(kv => kv.Key, kv => kv.Value);
var payload = new
{
command = "edit_user",
token = token,
arguments = arguments
};
Console.WriteLine("📤 Sending edit user request...");
string response = SendRequest(serverIp, serverPort, payload);
Console.WriteLine("✔️ Response from server:");
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 List<string> GetListArgument(string[] args, string key)
{
int index = Array.IndexOf(args, key);
List<string> values = new List<string>();
if (index >= 0)
{
for (int i = index + 1; i < args.Length && !args[i].StartsWith("--"); i++)
{
values.Add(args[i]);
}
}
return values;
}
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();
// Send payload
byte[] data = Encoding.UTF8.GetBytes(payloadJson);
stream.Write(data, 0, data.Length);
// Receive response
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_edit_user.cs:
--------------------------------------------------------------------------------
```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using Newtonsoft.Json;
namespace MCPEditUserClient
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 4)
{
Console.WriteLine("Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --user-id <USER_ID> [optional parameters]");
return;
}
string serverIp = GetArgument(args, "--server-ip");
int serverPort = int.Parse(GetArgument(args, "--server-port"));
string token = GetArgument(args, "--token");
string userId = GetArgument(args, "--user-id");
string name = GetArgument(args, "--name");
string email = GetArgument(args, "--email");
string password = GetArgument(args, "--password");
string language = GetArgument(args, "--language");
string timezone = GetArgument(args, "--timezone");
List<string> roles = GetListArgument(args, "--roles");
List<string> groups = GetListArgument(args, "--groups");
bool usePublic = Array.Exists(args, arg => arg == "--usePublic");
bool activateFtp = Array.Exists(args, arg => arg == "--activateFtp");
string ftpPassword = GetArgument(args, "--ftpPassword");
var arguments = new Dictionary<string, object>
{
{ "userId", userId },
{ "name", name },
{ "email", email },
{ "password", password },
{ "language", language },
{ "timezone", timezone },
{ "roles", roles },
{ "groups", groups },
{ "usePublic", usePublic },
{ "activateFtp", activateFtp },
{ "ftpPassword", ftpPassword }
};
// Remove null or empty values from arguments
arguments = arguments.Where(kv => kv.Value != null && !(kv.Value is string str && string.IsNullOrWhiteSpace(str))).ToDictionary(kv => kv.Key, kv => kv.Value);
var payload = new
{
command = "edit_user",
token = token,
arguments = arguments
};
Console.WriteLine("📤 Sending edit user request...");
string response = SendRequest(serverIp, serverPort, payload);
Console.WriteLine("✔️ Response from server:");
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 List<string> GetListArgument(string[] args, string key)
{
int index = Array.IndexOf(args, key);
List<string> values = new List<string>();
if (index >= 0)
{
for (int i = index + 1; i < args.Length && !args[i].StartsWith("--"); i++)
{
values.Add(args[i]);
}
}
return values;
}
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();
// Send payload
byte[] data = Encoding.UTF8.GetBytes(payloadJson);
stream.Write(data, 0, data.Length);
// Receive response
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/JavaScript/3.4 mcp_delete_source/MCPDeleteSourceClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--source-id':
parsedArgs.sourceId = args[++i];
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer Delete-Source-Anfrage über eine TCP-Verbindung
function sendDeleteSourceRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
const TIMEOUT_DURATION = 10000; // 10 Sekunden
// Setze einen Timeout
const timeout = setTimeout(() => {
client.destroy(); // Zerstöre die Verbindung
reject(new Error('Verbindungs-Timeout: Der Server hat nicht rechtzeitig geantwortet.'));
}, TIMEOUT_DURATION);
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
clearTimeout(timeout); // Entferne den Timeout
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
clearTimeout(timeout); // Entferne den Timeout
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
clearTimeout(timeout); // Entferne den Timeout
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
let { serverIp, serverPort, token, sourceId } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind, sonst interaktiv abfragen
if (!serverIp) {
serverIp = await askQuestion('🔗 Bitte gib die Server-IP ein: ');
}
if (!serverPort) {
const portInput = await askQuestion('🔗 Bitte gib den Server-Port ein: ');
serverPort = parseInt(portInput, 10);
}
if (!token) {
token = await askQuestion('🔒 Bitte gib dein Authentifizierungstoken ein: ');
}
if (!sourceId) {
sourceId = await askQuestion('📁 Bitte gib die Source-ID ein: ');
}
const payload = {
command: "delete_source",
token: token,
arguments: {
sourceId: sourceId
}
};
try {
console.log('🗑️ Sende Delete-Source-Anfrage...');
const response = await sendDeleteSourceRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/agents/OpenAI_Compatible_API_Agent/Python/vllmproxy.py:
--------------------------------------------------------------------------------
```python
import argparse
import asyncio
import json
import time
import httpx
from openai import OpenAI
from openai.types.chat import ChatCompletionUserMessageParam, ChatCompletionAssistantMessageParam, \
ChatCompletionSystemMessageParam, ChatCompletionToolParam
from starlette.responses import StreamingResponse
from fastapi import FastAPI, Request, HTTPException
from threading import local
from agents.OpenAI_Compatible_API_Agent.Python.open_ai_helper import ChatCompletionRequest, models, Message, num_tokens, \
CompletionRequest
import uvicorn
app = FastAPI(title="OpenAI-compatible API for PrivateGPT")
request_context = local()
@app.middleware("http")
async def store_request_headers(request: Request, call_next):
request_context.headers = dict(request.headers)
response = await call_next(request)
return response
@app.post("/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
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)
)
msgs = []
for message in request.messages:
if message.role == "system":
msgs.append(ChatCompletionSystemMessageParam(role="system", content=message.content))
elif message.role == "user":
msgs.append(ChatCompletionUserMessageParam(role="user", content=message.content))
elif message.role == "assistant":
msgs.append(ChatCompletionAssistantMessageParam(role="assistant", content=message.content))
tools = []
#tools_json = json.loads(json.dumps(request.tools))
#for tool in tools_json:
# tools.append(json.loads(str(tool)))
#if len(tools) == 0:
# tools = None
response = client.chat.completions.create(
model="/models/mistral-nemo-12b",
temperature=request.temperature,
#top_p=float(request.top_p),
stream=True,
tools=tools or None,
messages=msgs
)
if request.stream:
return StreamingResponse(
_resp_async_generator_vllm(response, request), media_type="application/x-ndjson"
)
else:
return {
"id": response.id,
"object": "chat.completion",
"created": time.time(),
"model": request.model,
"choices": [{"message": Message(role="assistant", content="Response", tool_calls=[])}],
"citations": [],
"usage": {
"prompt_tokens": 10,
"completion_tokens": 10,
"total_tokens": 20
}
}
async def _resp_async_generator_vllm(response, request):
partial_message = ""
user_input = ""
for message in request.messages:
user_input += json.dumps({'role': message.role, 'content': message.content})
i = 0
for chunk in response:
num_tokens_request, num_tokens_reply, num_tokens_overall = num_tokens(user_input, chunk.choices[0].delta.content)
chunk = {
"id": i,
"object": "chat.completion.chunk",
"created": time.time(),
"model": request.model,
"choices": [{"delta": {"content": chunk.choices[0].delta.content}}],
"usage": {
"prompt_tokens": num_tokens_request,
"completion_tokens": num_tokens_reply,
"total_tokens": num_tokens_overall
}
}
i = i+1
yield f"data: {json.dumps(chunk)}\n\n"
await asyncio.sleep(0.05)
yield "data: [DONE]\n\n"
@app.get("/models")
def return_models():
return {
"object": "list",
"data": models
}
@app.get('/models/{model_id}')
async def get_model(model_id: str):
filtered_entries = list(filter(lambda item: item["id"] == model_id, models))
entry = filtered_entries[0] if filtered_entries else None
print(entry)
if entry is None:
raise HTTPException(status_code=404, detail="Model not found")
return entry
if __name__ == "__main__":
api_ip = "0.0.0.0"
api_port = 8003
uvicorn.run(app, host=api_ip, port=int(api_port))
```
--------------------------------------------------------------------------------
/clients/Python/5.1 mcp_edit_user/MCPEditUserClient.py:
--------------------------------------------------------------------------------
```python
import socket
import ssl
import json
import argparse
import sys
def send_edit_user_request(server_ip, server_port, token, name=None, email=None, password=None, language=None,
timezone=None, roles=None, groups=None, use_public=False, activate_ftp=False, ftp_password=None,
use_ssl=True, accept_self_signed=False):
"""
Sends a request to edit an existing user to the MCP server.
"""
payload = {
"command": "edit_user",
"token": token,
"arguments": {
"name": name,
"email": email,
"password": password,
"language": language,
"timezone": timezone,
"roles": roles or [],
"groups": groups or [],
"usePublic": use_public,
"activateFtp": activate_ftp,
"ftpPassword": ftp_password
}
}
# Remove keys with None values
payload["arguments"] = {k: v for k, v in payload["arguments"].items() if v is not None}
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: Server and/or client may require 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 request to edit an existing user to the MCP server.",
formatter_class=argparse.RawTextHelpFormatter
)
parser.add_argument("--server-ip", required=True, help="IP address of the MCP server")
parser.add_argument("--server-port", required=True, type=int, help="Port number of the MCP server")
parser.add_argument("--token", required=True, help="Authentication token")
parser.add_argument("--name", help="New name of the user")
parser.add_argument("--email", help="New email of the user")
parser.add_argument("--password", help="New password of the user")
parser.add_argument("--language", help="Preferred language of the user")
parser.add_argument("--timezone", help="Timezone of the user")
parser.add_argument("--roles", nargs="*", help="List of roles to assign to the user")
parser.add_argument("--groups", nargs="*", help="List of groups to assign to the user")
parser.add_argument("--usePublic", action="store_true", help="Enable public knowledge base access")
parser.add_argument("--activateFtp", action="store_true", help="Activate FTP access")
parser.add_argument("--ftpPassword", help="Password for FTP access")
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)")
if len(sys.argv) == 1:
parser.print_help(sys.stderr)
sys.exit(1)
args = parser.parse_args()
response = send_edit_user_request(
args.server_ip,
args.server_port,
args.token,
name=args.name,
email=args.email,
password=args.password,
language=args.language,
timezone=args.timezone,
roles=args.roles,
groups=args.groups,
use_public=args.usePublic,
activate_ftp=args.activateFtp,
ftp_password=args.ftpPassword,
use_ssl=args.use_ssl,
accept_self_signed=args.accept_self_signed
)
print("Response from server:", response)
```
--------------------------------------------------------------------------------
/clients/JavaScript/2.0 mcp_chat/MCPChatClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--question':
parsedArgs.question = args[++i];
break;
case '--use-public':
parsedArgs.usePublic = true;
break;
case '--groups':
// Sammle alle Gruppenargumente bis zum nächsten Flag oder Ende
parsedArgs.groups = [];
while (i + 1 < args.length && !args[i + 1].startsWith('--')) {
parsedArgs.groups.push(args[++i]);
}
break;
case '--language':
parsedArgs.language = args[++i];
break;
default:
console.warn(`Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer Chat-Anfrage über eine TCP-Verbindung
function sendChatRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
client.connect(serverPort, serverIp, () => {
console.log('🔗 Verbindung zum Server hergestellt.');
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
const { serverIp, serverPort, token, question, usePublic, groups, language } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind
if (!serverIp || !serverPort || !token || !question) {
console.error('❌ ERROR: Fehlende erforderliche Parameter.');
console.log('Verwendung: node MCPChatClient.js --server-ip <IP> --server-port <Port> --token <Token> --question <Frage> [--use-public] [--groups <Gruppe1> <Gruppe2> ...] [--language <Sprache>]');
exit(1);
}
// Optional: Fallback für optionale Parameter
const finalLanguage = language || 'de';
const finalGroups = groups || [];
const payload = {
command: "chat",
token: token,
arguments: {
question: question,
usePublic: usePublic || false,
groups: finalGroups,
language: finalLanguage
}
};
try {
console.log('💬 Sende Chat-Anfrage...');
const response = await sendChatRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```
--------------------------------------------------------------------------------
/src/services/pgpt-service.ts:
--------------------------------------------------------------------------------
```typescript
import axios, { AxiosInstance } from 'axios';
import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
import { ChatArgs, SourceArgs, ListSourcesArgs, GetSourceArgs } from '../types/api.js';
export class PGPTService {
private api: AxiosInstance;
private token: string | null = null;
constructor() {
// Initialize axios instance with base configuration
this.api = axios.create({
baseURL: process.env.PGPT_API_URL || 'http://localhost:3000',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
},
});
}
private async ensureAuthenticated(): Promise<void> {
if (!this.token) {
const email = process.env.PGPT_EMAIL;
const password = process.env.PGPT_PASSWORD;
if (!email || !password) {
throw new McpError(
ErrorCode.InvalidRequest,
'Missing authentication credentials'
);
}
try {
const response = await this.api.post('/api/v1/login', {
email,
password,
});
this.token = response.data.data.token;
this.api.defaults.headers.common['Authorization'] = `Bearer ${this.token}`;
} catch (error) {
throw new McpError(
ErrorCode.InvalidRequest,
'Authentication failed'
);
}
}
}
async chat(args: ChatArgs) {
await this.ensureAuthenticated();
try {
const response = await this.api.post('/api/v1/chats', {
language: args.language || 'en',
question: args.question,
usePublic: args.usePublic || false,
groups: args.groups || [],
});
return {
content: [
{
type: 'text',
text: response.data.data.answer,
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
throw new McpError(
ErrorCode.InternalError,
`Chat failed: ${error.response?.data?.message || error.message}`
);
}
throw error;
}
}
async createSource(args: SourceArgs) {
await this.ensureAuthenticated();
try {
const response = await this.api.post('/api/v1/sources', {
name: args.name,
content: args.content,
groups: args.groups || [],
});
return {
content: [
{
type: 'text',
text: JSON.stringify(response.data.data, null, 2),
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
throw new McpError(
ErrorCode.InternalError,
`Source creation failed: ${error.response?.data?.message || error.message}`
);
}
throw error;
}
}
async listGroups() {
await this.ensureAuthenticated();
try {
const response = await this.api.get('/api/v1/groups');
return {
content: [
{
type: 'text',
text: JSON.stringify(response.data.data, null, 2),
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
throw new McpError(
ErrorCode.InternalError,
`Group listing failed: ${error.response?.data?.message || error.message}`
);
}
throw error;
}
}
async listSources(args: ListSourcesArgs) {
await this.ensureAuthenticated();
try {
const response = await this.api.post('/api/v1/sources/groups', {
groupName: args.groupName,
});
return {
content: [
{
type: 'text',
text: JSON.stringify(response.data.data, null, 2),
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
throw new McpError(
ErrorCode.InternalError,
`Source listing failed: ${error.response?.data?.message || error.message}`
);
}
throw error;
}
}
async getSource(args: GetSourceArgs) {
await this.ensureAuthenticated();
try {
const response = await this.api.get(`/api/v1/sources/${args.sourceId}`);
return {
content: [
{
type: 'text',
text: JSON.stringify(response.data.data, null, 2),
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
throw new McpError(
ErrorCode.InternalError,
`Source retrieval failed: ${error.response?.data?.message || error.message}`
);
}
throw error;
}
}
}
```
--------------------------------------------------------------------------------
/clients/C++/3.3 mcp_edit_source/MCPEditSourceClient.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <sstream>
#include <stdexcept>
#include <json/json.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib") // Winsock-Bibliothek verlinken
// Funktion zum Argument-Parsing
std::map<std::string, std::string> parseArguments(int argc, char* argv[], std::vector<std::string>& groups) {
std::map<std::string, std::string> args;
for (int i = 1; i < argc; ++i) {
std::string key = argv[i];
if (i + 1 < argc && key.rfind("--", 0) == 0) {
if (key == "--groups") {
while (++i < argc && argv[i][0] != '-') {
groups.push_back(argv[i]);
}
--i; // Rückgängigmachen des letzten Schritts
} else {
args[key] = argv[++i];
}
}
}
return args;
}
// Funktion zum Senden der Anfrage
std::string sendRequest(const std::string& serverIp, int serverPort, const Json::Value& payload) {
Json::StreamWriterBuilder writer;
std::string payloadJson = Json::writeString(writer, payload);
// Winsock initialisieren
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
throw std::runtime_error("Failed to initialize Winsock.");
}
// Socket erstellen
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
WSACleanup();
throw std::runtime_error("Failed to create socket.");
}
// Server-Adresse konfigurieren
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(serverPort);
if (inet_pton(AF_INET, serverIp.c_str(), &serverAddr.sin_addr) <= 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Invalid server IP address.");
}
// Verbindung herstellen
if (connect(sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Connection failed.");
}
// Daten senden
if (send(sock, payloadJson.c_str(), payloadJson.size(), 0) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Failed to send data.");
}
// Antwort empfangen
char buffer[4096];
int bytesRead;
std::ostringstream response;
do {
bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (bytesRead > 0) {
buffer[bytesRead] = '\0'; // Null-terminieren
response << buffer;
}
} while (bytesRead == sizeof(buffer) - 1);
// Socket schließen
closesocket(sock);
WSACleanup();
return response.str();
}
int main(int argc, char* argv[]) {
try {
std::vector<std::string> groups;
auto args = parseArguments(argc, argv, groups);
// Argumente extrahieren
std::string serverIp = args["--server-ip"];
int serverPort = std::stoi(args["--server-port"]);
std::string token = args["--token"];
std::string sourceId = args["--source-id"];
std::string title = args["--title"];
std::string content = args["--content"];
// Überprüfen, ob alle erforderlichen Parameter angegeben sind
if (serverIp.empty() || serverPort == 0 || token.empty() || sourceId.empty()) {
std::cerr << "Usage: MCPEditSourceClient --server-ip <IP> --server-port <PORT> --token <TOKEN> --source-id <SOURCE_ID> [--title <TITLE>] [--content <CONTENT>] [--groups <GROUP1 GROUP2 ...>]\n";
return 1;
}
std::cout << "📤 Sending request to edit the source...\n";
// JSON-Payload erstellen
Json::Value payload;
payload["command"] = "edit_source";
payload["token"] = token;
Json::Value arguments;
arguments["sourceId"] = sourceId;
if (!title.empty()) {
arguments["title"] = title;
}
if (!content.empty()) {
arguments["content"] = content;
}
Json::Value groupsJson(Json::arrayValue);
for (const auto& group : groups) {
groupsJson.append(group);
}
arguments["groups"] = groupsJson;
payload["arguments"] = arguments;
// Anfrage senden und Antwort erhalten
std::string response = sendRequest(serverIp, serverPort, payload);
std::cout << "✔️ Response from server:\n" << response << "\n";
} catch (const std::exception& e) {
std::cerr << "❌ ERROR: " << e.what() << "\n";
return 1;
}
return 0;
}
```
--------------------------------------------------------------------------------
/clients/C++/2.0 mcp_chat/MCPChatClient.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <stdexcept>
#include <json/json.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib") // Winsock-Bibliothek verlinken
// Funktion zum Argument-Parsing
std::map<std::string, std::string> parseArguments(int argc, char* argv[]) {
std::map<std::string, std::string> args;
for (int i = 1; i < argc; ++i) {
std::string key = argv[i];
if (i + 1 < argc && key.rfind("--", 0) == 0) {
args[key] = argv[++i];
}
}
return args;
}
// Funktion zum Senden der MCP-Anfrage
std::string sendMCPRequest(const std::string& serverIp, int serverPort, const std::string& token,
const std::string& question, bool usePublic, const std::vector<std::string>& groups,
const std::string& language) {
// JSON-Payload erstellen
Json::Value payload;
payload["command"] = "chat";
payload["token"] = token;
payload["arguments"]["question"] = question;
payload["arguments"]["usePublic"] = usePublic;
payload["arguments"]["language"] = language;
Json::Value groupsJson(Json::arrayValue);
for (const auto& group : groups) {
groupsJson.append(group);
}
payload["arguments"]["groups"] = groupsJson;
Json::StreamWriterBuilder writer;
std::string payloadJson = Json::writeString(writer, payload);
// Winsock initialisieren
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
throw std::runtime_error("Failed to initialize Winsock.");
}
// Socket erstellen
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
WSACleanup();
throw std::runtime_error("Failed to create socket.");
}
// Server-Adresse konfigurieren
sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(serverPort);
if (inet_pton(AF_INET, serverIp.c_str(), &serverAddr.sin_addr) <= 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Invalid server IP address.");
}
// Verbindung herstellen
if (connect(sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Connection failed.");
}
// Daten senden
if (send(sock, payloadJson.c_str(), payloadJson.size(), 0) < 0) {
closesocket(sock);
WSACleanup();
throw std::runtime_error("Failed to send data.");
}
// Antwort empfangen
char buffer[4096];
int bytesRead;
std::ostringstream response;
do {
bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (bytesRead > 0) {
buffer[bytesRead] = '\0'; // Null-terminieren
response << buffer;
}
} while (bytesRead == sizeof(buffer) - 1);
// Socket schließen
closesocket(sock);
WSACleanup();
return response.str();
}
int main(int argc, char* argv[]) {
try {
auto args = parseArguments(argc, argv);
// Argumente extrahieren
std::string serverIp = args["--server-ip"];
int serverPort = std::stoi(args["--server-port"]);
std::string token = args["--token"];
std::string question = args["--question"];
bool usePublic = args.find("--use-public") != args.end();
std::string language = args.count("--language") ? args["--language"] : "de";
// Gruppen extrahieren
std::vector<std::string> groups;
if (args.count("--groups")) {
std::istringstream groupStream(args["--groups"]);
std::string group;
while (std::getline(groupStream, group, ',')) {
groups.push_back(group);
}
}
// Überprüfen, ob alle erforderlichen Parameter angegeben sind
if (serverIp.empty() || serverPort == 0 || token.empty() || question.empty()) {
std::cerr << "Usage: --server-ip <IP> --server-port <PORT> --token <TOKEN> --question <QUESTION> [--use-public] [--groups <GROUPS>] [--language <LANGUAGE>]\n";
return 1;
}
std::cout << "🔒 Sending MCP chat request...\n";
// MCP-Anfrage senden und Antwort erhalten
std::string response = sendMCPRequest(serverIp, serverPort, token, question, usePublic, groups, language);
std::cout << "Response from server:\n" << response << "\n";
} catch (const std::exception& e) {
std::cerr << "❌ ERROR: " << e.what() << "\n";
return 1;
}
return 0;
}
```
--------------------------------------------------------------------------------
/clients/JavaScript/3.0 mcp_create_source/MCPCreateSourceClient.js:
--------------------------------------------------------------------------------
```javascript
const net = require('net');
const readline = require('readline');
const { argv, exit } = require('process');
// Funktion zum Parsen der Kommandozeilenargumente
function parseArguments(args) {
const parsedArgs = {};
for (let i = 2; i < args.length; i++) {
switch (args[i]) {
case '--server-ip':
parsedArgs.serverIp = args[++i];
break;
case '--server-port':
parsedArgs.serverPort = parseInt(args[++i], 10);
break;
case '--token':
parsedArgs.token = args[++i];
break;
case '--name':
parsedArgs.name = args[++i];
break;
case '--content':
parsedArgs.content = args[++i];
break;
case '--groups':
// Sammle alle Gruppenargumente bis zum nächsten Flag oder Ende
parsedArgs.groups = [];
while (i + 1 < args.length && !args[i + 1].startsWith('--')) {
parsedArgs.groups.push(args[++i]);
}
break;
default:
console.warn(`⚠️ Unbekanntes Argument: ${args[i]}`);
}
}
return parsedArgs;
}
// Funktion zum interaktiven Abfragen eines Parameters (optional)
function askQuestion(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: true
});
return new Promise((resolve) => {
rl.question(query, (answer) => {
rl.close();
resolve(answer);
});
});
}
// Funktion zum Senden einer Create-Source-Anfrage über eine TCP-Verbindung
function sendCreateSourceRequest(serverIp, serverPort, payload) {
return new Promise((resolve, reject) => {
const client = new net.Socket();
let responseData = '';
client.connect(serverPort, serverIp, () => {
console.log(`🔗 Verbindung zum Server (${serverIp}:${serverPort}) hergestellt.`);
const payloadString = JSON.stringify(payload);
console.log(`📤 Sende Payload: ${payloadString}`);
client.write(payloadString);
});
client.on('data', (data) => {
console.log(`📥 Empfangene Daten: ${data}`);
responseData += data.toString();
try {
const parsedData = JSON.parse(responseData);
console.log('✅ JSON-Antwort erfolgreich geparst.');
resolve(parsedData);
client.destroy(); // Verbindung schließen
} catch (err) {
console.warn('⚠️ Antwort noch nicht vollständig oder ungültiges JSON. Weitere Daten werden erwartet.');
// Antwort noch nicht vollständig, weiter empfangen
}
});
client.on('close', () => {
console.log('🔒 Verbindung zum Server geschlossen.');
});
client.on('error', (err) => {
console.error('❌ Verbindungsfehler:', err.message);
reject(err);
});
});
}
// Hauptfunktion
async function main() {
const args = argv;
const parsedArgs = parseArguments(args);
let { serverIp, serverPort, token, name, content, groups } = parsedArgs;
// Überprüfen, ob alle erforderlichen Parameter vorhanden sind, sonst interaktiv abfragen
if (!serverIp) {
serverIp = await askQuestion('🔗 Bitte gib die Server-IP ein: ');
}
if (!serverPort) {
const portInput = await askQuestion('🔗 Bitte gib den Server-Port ein: ');
serverPort = parseInt(portInput, 10);
}
if (!token) {
token = await askQuestion('🔒 Bitte gib dein Authentifizierungstoken ein: ');
}
if (!name) {
name = await askQuestion('📛 Bitte gib den Namen der neuen Quelle ein: ');
}
if (!content) {
content = await askQuestion('📝 Bitte gib den Inhalt der neuen Quelle (Markdown) ein: ');
}
if (!groups) {
const groupsInput = await askQuestion('👥 Bitte gib die Gruppen an (getrennt durch Leerzeichen, optional): ');
groups = groupsInput ? groupsInput.split(' ') : [];
}
const payload = {
command: "create_source",
token: token,
arguments: {
name: name,
content: content,
groups: groups
}
};
try {
console.log('🛠️ Sende Create-Source-Anfrage...');
const response = await sendCreateSourceRequest(serverIp, serverPort, payload);
console.log('✅ Server Response:');
console.log(JSON.stringify(response, null, 2));
} catch (err) {
console.error('❌ ERROR:', err.message);
}
}
main();
```