From child-friendly activities through to cellar tours and Michelin-starred restaurants, the below selection highlights the best of what you can do in Bordeaux in 2023 and has something for every wine lover.
{"content":"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"}