# Forefront MCP > Forefront MCP lets your agent connect directly to advanced language models for development tasks. Generate chat responses, train custom LLMs using private datasets, and build data pipelines to automatically collect, track, and organize model outputs. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** llm, fine-tuning, text-generation, pipelines, ai-models ## Description Your AI client talks directly to the Forefront platform through this MCP. You can ask it to write text based on a simple prompt or handle complex conversations using a dedicated chat format. Beyond basic generation, you manage custom training jobs by feeding base models your private datasets. Crucially, you build data pipelines that automatically collect and organize every piece of LLM output, making tracking metadata easy. If you're looking for a central place to connect all these advanced capabilities, check out the Vinkius catalog. This MCP gives developers exactly what they need: powerful model access combined with robust workflow management. ## Tools ### add_pipeline_data Adds data samples into an existing pipeline for later review or training use. ### list_pipelines Retrieves a list of all the automated data pipelines you have set up. ### create_chat_completion Generates model responses based on an array of messages, simulating a full chat conversation. ### create_completion Creates a response for a simple prompt string when you only need basic text generation. ### create_fine_tune Starts the process of training a custom, specialized language model using your proprietary data. ### create_pipeline_dataset Creates a usable dataset directly from a selected pipeline's gathered samples. ### create_pipeline Sets up a brand new, automated data collection pipeline to monitor LLM outputs. ### get_pipeline_count Returns the total number of pipelines currently managed by your account. ### get_pipeline_samples Retrieves data samples from a specific pipeline selection for inspection and use. ### get_pipeline Fetches the full details of an existing pipeline using its unique ID. ## Prompt Examples **Prompt:** ``` Generate a chat completion with model 'forefront-llm' asking 'What is the capital of France?' ``` **Response:** ``` I will call `create_chat_completion` with model 'forefront-llm' and the message 'What is the capital of France?'. The model responded: 'The capital of France is Paris.' ``` **Prompt:** ``` List all my active pipelines on Forefront. ``` **Response:** ``` I will query your pipelines using `list_pipelines`. I found 2 active pipelines: 'customer-feedback-pipeline' (ID: pipe_123) and 'qa-testing-pipeline' (ID: pipe_456). ``` **Prompt:** ``` Create a new pipeline named 'production-logs'. ``` **Response:** ``` I will call `create_pipeline` with the name 'production-logs'. The pipeline has been successfully created with ID 'pipe_789'. ``` ## Capabilities ### Generate Conversational Responses Your agent handles complex back-and-forth chats, simulating real user conversations to generate accurate model answers. ### Create Standalone Text Outputs You prompt the system with a single piece of text and get a direct completion response from the language model. ### Train Custom Models You initiate training jobs on base models using your own curated datasets for specialized, proprietary knowledge. ### Orchestrate Data Collection Pipelines You set up automated workflows to gather and organize model outputs, tracking samples and metadata across multiple steps. ## Use Cases ### Testing a Customer Service Bot A QA tester needs to check if the new customer service bot handles complex billing questions. They use `create_chat_completion` repeatedly with varied prompts, then use `get_pipeline_samples` to pull all those interactions into one sheet for reporting. ### Creating a Specialized Legal Model A legal tech firm needs an LLM trained on obscure case law. They first gather thousands of documents, then use `create_pipeline` to capture model outputs from those texts. Finally, they kick off the training with `create_fine_tune`. ### Monitoring Content Generation A marketing team wants to see how different prompts affect tone. They use `list_pipelines` to find their content generation pipeline, then manually add specific data points using `add_pipeline_data` so they can compare results later. ### Building a Recommendation Engine Dataset A developer needs data showing how users react to product descriptions. They use `create_completion` for thousands of variations, then run `create_pipeline_dataset` to package all the successful outputs into a ready-to-use training set. ## Benefits - Test complex conversations immediately. Instead of writing code to handle chat history, use `create_chat_completion` to simulate full user interactions and see how the model responds in context. - Stop wasting time on basic testing. Use `create_completion` for quick checks or when you just need a single prompt answered without conversation history overhead. - Build proprietary intelligence. You can run custom training jobs using `create_fine_tune`, ensuring the models speak your company's specific language and knowledge base. - Automate data gathering. Setting up pipelines is simple: use `create_pipeline` to define where you need to collect output, then use `list_pipelines` to see what’s active. - Organize outputs systematically. Once the pipeline runs, you can use tools like `get_pipeline_samples` and `add_pipeline_data` to keep track of every piece of data collected for review. ## How It Works The bottom line is that your AI client becomes a direct control panel for Forefront's entire suite of language model tools. 1. Subscribe to this MCP on Vinkius and enter your Forefront API Key. 2. Your agent uses the established connection to either generate text or start a new data collection pipeline. 3. You get access to model outputs, fine-tuning job status, and structured data samples for immediate use. ## Frequently Asked Questions **How do I start tracking model outputs with the Forefront MCP?** You begin by calling `create_pipeline` to set up a new pipeline. Once created, you can use `get_pipeline_count` to confirm its existence and then run tests that funnel data into it. **Is the Forefront MCP better than using my own API keys directly?** Yes. This MCP centralizes access, allowing your agent to manage not just simple generation but also complex workflows like fine-tuning and pipeline management—all through a single connection. **What is the difference between `create_completion` and `create_chat_completion`?** `create_completion` handles a single prompt string, which is great for simple tasks. Use `create_chat_completion` when you need to model multi-turn conversations because it accepts a full history of messages. **Can I train my own custom LLM using the Forefront MCP?** Absolutely. You use the `create_fine_tune` tool. This lets you upload your specific datasets and initiate training jobs on base models to create a specialized, proprietary model. **What if I need data from an existing pipeline?** You can retrieve that information using `get_pipeline_samples` or check the overall details with `get_pipeline(id)`. You’ll also have `create_pipeline_dataset` to turn those samples into a ready-to-use dataset.