float-mcp

--- title: Research Session query: 'Float.com REST API endpoints, authentication, rate limiting, projects, people, time tracking, scheduling, reporting capabilities' date: 7/8/2025 time: 12:29:01 PM timestamp: 2025-07-08T16:29:01.995Z exchanges: 1 --- # Research Session ## Initial Query **Question:** Float.com REST API endpoints, authentication, rate limiting, projects, people, time tracking, scheduling, reporting capabilities **Response:** ## Introduction to Float.com REST API The Float.com REST API is designed to provide programmatic access to Float's data, enabling integration with other platforms and automating various operations such as project management, people management, time tracking, and scheduling. This API is crucial for the project's tasks, including **Task 12: Float API Client Implementation**, **Task 13: Project Management Tools Implementation**, **Task 14: People & Resources Tools Implementation**, **Task 15: Time Tracking Tools Implementation**, and **Task 16: Scheduling Tools Implementation**. ### Authentication To use the Float API, you need to authenticate your requests. The Float API uses API tokens for authentication, which can be created and managed by logging into the Float app as an administrator and navigating to the "Developers" section under "Business Settings" in the settings menu[4]. Once you have an API token, you can include it in your API requests using the `Authorization` header with a `Bearer` token. **Example Authentication Header:** ```http Authorization: Bearer YOUR_API_TOKEN ``` ### API Endpoints While specific Float API endpoints for projects, people, time tracking, and scheduling are not detailed in the provided search results, you can access detailed documentation on the Float API endpoints through the official Float API documentation[4]. Typically, APIs for such platforms include endpoints for: - **Projects:** - `GET /projects`: Retrieve a list of all projects. - `GET /projects/{id}`: Get details of a specific project. - `POST /projects`: Create a new project. - `PUT /projects/{id}`: Update an existing project. - `DELETE /projects/{id}`: Delete a project. - **People:** - `GET /people`: Retrieve a list of all people. - `GET /people/{id}`: Get details of a specific person. - `POST /people`: Create a new person record. - `PUT /people/{id}`: Update an existing person's details. - `DELETE /people/{id}`: Delete a person record. - **Time Tracking:** - `POST /time_entries`: Log a new time entry. - `GET /time_entries`: Retrieve time entries with optional filtering. - `PUT /time_entries/{id}`: Update an existing time entry. - `DELETE /time_entries/{id}`: Delete a time entry. - **Scheduling:** - `GET /schedules`: Retrieve scheduled assignments with filtering. - `POST /schedules`: Create a new schedule assignment. - `PUT /schedules/{id}`: Update an existing schedule. - `DELETE /schedules/{id}`: Delete a scheduled assignment. ### Rate Limiting APIs often implement rate limiting to prevent abuse and ensure fair usage. While specific details on Float's rate limiting are not provided, it's common for APIs to return a `429 Too Many Requests` status code when the limit is exceeded. Implementing exponential backoff in your client can help handle such scenarios by waiting longer between retries[2][4]. **Example Rate Limiting Handling in Python:** ```python import time import requests def handle_rate_limit(response): if response.status_code == 429: # Wait for a bit before retrying time.sleep(1) # Initial delay while response.status_code == 429: time.sleep(1) # Increase delay on subsequent retries response = requests.get(url, headers=headers) return response ``` ### Reporting Capabilities The Float API allows you to access transaction-level data and real-time spend and deposit information, which can be used to create custom reports or integrate with reporting tools[4]. This capability is essential for tasks like **Task 15: Time Tracking Tools Implementation** and **Task 16: Scheduling Tools Implementation**, where detailed reporting can help in managing resources and capacity planning. ### Implementation in Project Context For tasks like **Task 12: Float API Client Implementation**, you will need to create a Python client that handles authentication, rate limiting, and error handling. Here’s a basic structure for such a client: ```python import requests import time class FloatAPIClient: def __init__(self, api_token): self.api_token = api_token self.base_url = "https://api.float.com" # Replace with actual base URL self.headers = { 'Authorization': f'Bearer {api_token}', 'Content-Type': 'application/json' } def get_projects(self): url = f"{self.base_url}/projects" response = requests.get(url, headers=self.headers) return self.handle_response(response) def handle_response(self, response): if response.status_code == 429: # Handle rate limiting time.sleep(1) # Initial delay while response.status_code == 429: time.sleep(1) # Increase delay on subsequent retries response = requests.get(url, headers=self.headers) elif response.status_code >= 400: # Handle other errors raise Exception(f"Error {response.status_code}: {response.text}") return response.json() # Usage client = FloatAPIClient("YOUR_API_TOKEN") projects = client.get_projects() print(projects) ``` ### Testing and Quality Assurance For **Task 25: Testing and Quality Assurance**, ensure that your tests cover all aspects of the API client and tools implementation. This includes unit tests for each method, integration tests with mocked API responses, and end-to-end tests with actual API calls. Use tools like `pytest` for unit testing and `requests_mock` for mocking API responses. **Example Test Setup:** ```python import pytest from unittest.mock import patch, MagicMock from your_module import FloatAPIClient @pytest.fixture def client(): return FloatAPIClient("TEST_API_TOKEN") def test_get_projects(client): with patch('requests.get') as mock_get: mock_response = MagicMock() mock_response.json.return_value = [{"id": 1, "name": "Project 1"}] mock_get.return_value = mock_response projects = client.get_projects() assert projects == [{"id": 1, "name": "Project 1"}] ``` ### Documentation and Setup Instructions For **Task 24: Documentation**, ensure that your README includes clear setup instructions for the Float API client, examples of how to use the client for different operations, and troubleshooting tips. Document all available tools with examples and provide detailed API documentation for the Float API client. **Example README Structure:** ````markdown # Float MCP Server Documentation ## Overview This project provides a Python client for the Float.com REST API, enabling integration with project management tools. ## Setup Instructions 1. Install required packages: `pip install requests` 2. Set up your Float API token: Follow instructions in the Float app. 3. Use the client: Import and instantiate the `FloatAPIClient` class. ## API Documentation ### Endpoints - `GET /projects`: Retrieve all projects. - `GET /projects/{id}`: Get a specific project. ### Examples ```python client = FloatAPIClient("YOUR_API_TOKEN") projects = client.get_projects() print(projects) ``` ```` ## Troubleshooting - **Rate Limiting:** If you encounter a `429` status code, wait a bit before retrying. ```` ### Docker Setup and Configuration For **Task 24: Documentation**, include instructions on how to set up and configure Docker for the Float MCP server. This involves creating a Dockerfile, building the image, and running the container. **Example Dockerfile:** ```dockerfile FROM python:3.9-slim # Set working directory to /app WORKDIR /app # Copy requirements file COPY requirements.txt . # Install dependencies RUN pip install --no-cache-dir -r requirements.txt # Copy application code COPY . . # Run command when container launches CMD ["python", "main.py"] ```` ### Claude Desktop Integration Guide For integrating with Claude Desktop, document how to set up the integration, including any necessary configuration or API keys. This guide should cover how to use the integration for common use cases. ### Testing Procedures Document the testing procedures for the Float MCP server, including how to run unit tests, integration tests, and end-to-end tests. Ensure that the documentation covers how to verify the results of these tests. ### Development Setup Instructions Provide detailed instructions on how to set up the development environment for the Float MCP server. This includes installing necessary packages, setting up the Float API client, and configuring any development tools like IDEs or debuggers. ### Environment Variables and Configuration Options Document all environment variables and configuration options available for the Float MCP server. Explain how to set these variables and what impact they have on the application's behavior. ### Common Use Cases Include examples of common use cases for the Float API client and tools implementation. This helps developers understand how to apply the tools in real-world scenarios. ### Troubleshooting Section Create a comprehensive troubleshooting section that addresses common issues encountered when using the Float API client and tools. Provide step-by-step solutions or workarounds for these issues. ### Log and Monitoring Setup For **Task 22: Logging and Monitoring**, set up structured logging using Python's logging module. Configure different log levels and implement request/response logging with sensitive data redaction. Add performance monitoring for API calls and create log formatters for different environments. **Example Logging Setup:** ```python import logging # Set up logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') # Create a logger logger = logging.getLogger(__name__) # Log a message logger.info("API call successful") ``` ### Performance Testing Implement performance testing for the API client to ensure it can handle a high volume of requests efficiently. Use tools like `locust` for load testing. **Example Performance Test:** ```python from locust import HttpLocust, TaskSet, task class FloatAPITasks(TaskSet): @task def get_projects(self): self.client.get("/projects") class FloatAPILocust(HttpLocust): task_set = FloatAPITasks min_wait = 5000 max_wait = 9000 ``` By following these guidelines and implementing these features, you can create a robust and well-documented Float MCP server that effectively integrates with the Float API for project management, people management, time tracking, and scheduling operations. --- _Generated by Task Master Research Command_ _Timestamp: 2025-07-08T16:29:01.995Z_